How I Track GitHub Commits Across All My Side Projects in One Place
At one point last year, I had five active GitHub repositories. Two personal side projects, one open source contribution, a freelance client project, and an experimental thing I started on a weekend. Each had its own commit history, its own pace, and its own "when did I last touch this?" question that I could never answer without opening GitHub.
I found myself doing this multiple times a day: open GitHub, click into a repo, check the commit log, try to remember if that last commit was yesterday or three days ago. Then repeat for the next repo. It was a small friction, but small frictions compound.
Here is the system I built to see all my commits in one timeline without leaving my browser.
The Problem with Repo-Hopping
GitHub is excellent for individual repositories. The commit log, the PR history, the contribution graph. All great when you are focused on one project.
But when you are juggling multiple side projects, GitHub's repo-centric design works against you:
- No cross-repo timeline. You cannot see "what did I do across all projects today?" without visiting each repo separately.
- Context switching cost. Every repo hop breaks your train of thought. You went to check one commit message and now you are reading an old issue.
- Progress blindness. Without a unified view, it is easy to think you are making progress everywhere when you are actually only pushing to one repo and neglecting the others.
- Multiple accounts. If you have a personal GitHub and a work GitHub (or a client's org), the fragmentation doubles.
What I Tried First
GitHub's contribution graph. The green squares are motivating but useless for cross-project awareness. They show activity, not what you actually did or where.
GitHub notifications. These tell you about other people's activity, not yours. And the signal-to-noise ratio is rough.
A text file log. I tried keeping a manual log of daily commits. This lasted exactly four days before I forgot to update it.
Third-party dashboard tools. Most of these are designed for teams and managers, not solo developers tracking their own side projects. Overkill for what I needed.
The Unified Timeline Approach
What I actually wanted was simple: open one page and see a chronological list of my commits across all repos, mixed in with other project activity. No setup every morning. No manual logging. Just a timeline that updates itself.
The key insight was that this should live where I already spend time. Not in a separate app I would forget to open, but in my browser, visible every time I open a new tab.
I set this up using STACKFOLO, which connects to GitHub via personal access tokens and pulls commit history into a unified timeline. But the concept works with any system that aggregates commit data. Here is why the approach matters more than the specific tool.
What a Unified Commit Timeline Shows You
1. Where Your Time Actually Goes
When I first set up my cross-repo timeline, I had a surprise. I thought I was splitting time roughly equally between my two main side projects. The timeline showed I had made 23 commits to Project A in the past two weeks and 2 commits to Project B. Project B was not "on pause." It was abandoned, and I had not noticed.
2. Momentum Gaps
A timeline makes gaps visible. If your last commit to a repo was 9 days ago, you see it immediately. Without a unified view, these gaps hide behind your other activity. You feel productive because you pushed code today, but you pushed to the same repo you always push to.
3. Context Recovery
When you come back to a project after a break, the first question is "where did I leave off?" A commit timeline answers this in seconds. Your last three commit messages tell you what you were working on, and you can jump back in without re-reading your code.
4. Cross-Project Patterns
After a few weeks of data, I noticed patterns:
- I only pushed to my open source project on weekends
- My freelance commits clustered on Tuesday and Thursday evenings
- My personal projects got attention in bursts (5 commits in one day, then silence for a week)
This was not intentional. Once I saw the pattern, I could decide whether to keep it or change it. I moved my open source contribution to Wednesday mornings, which turned out to be a better fit.
Setting Up Multi-Account Tracking
One thing that surprised me: most developers I talk to have more than one GitHub account. Personal, work, sometimes a client org account. Tracking commits across accounts is harder than tracking across repos within one account.
The approach I use:
- Generate a personal access token for each GitHub account (read-only scope is enough)
- Link each token to the projects that use that account
- The timeline merges everything chronologically, regardless of which account made the commit
This means my personal side project commits, my work repo commits, and my freelance client commits all appear in one stream. I can filter by project when I need to focus, or see everything when I want the big picture.
Beyond Commits: The Full Project Timeline
Commits are the backbone, but a useful project timeline includes more:
- Task completions. When you check off a to-do, it shows in the timeline alongside your commits.
- Resource saves. When you bookmark a Stack Overflow answer or save a documentation page for a project, it appears in context.
- Service events. Subscription renewals, deployment triggers, and domain renewals tied to specific projects.
- Manual notes. Sometimes you need to log "decided to pivot from REST to GraphQL" and have it appear in the timeline.
This turns the timeline from a commit log into a project diary. When you look back at a project three months later, you see the full story, not just the code changes.
Practical Tips for Any Setup
Whether you use a dedicated tool or build your own, here is what I have learned:
- Cache aggressively. GitHub API has rate limits. A 5-minute cache for commit data is enough for personal use and keeps things fast.
- Show repo names clearly. When commits from 5 repos are interleaved, you need to immediately see which project each commit belongs to.
- Make it visible. The timeline only works if you see it regularly. A browser new tab page, a pinned tab, or a widget on your desktop. Somewhere you cannot avoid.
- Filter by project when you are focused. The unified view is for awareness. When you sit down to code on Project A, filter to just that project so you can pick up where you left off.
- Do not over-engineer it. The point is awareness, not analytics. You do not need charts and graphs. A simple chronological list with dates, repo names, and commit messages is enough.
The Result
After three months with a unified commit timeline, I shipped two side projects that had been stalled for months. Not because the timeline gave me more time, but because it made my neglect visible. When you see "last commit: 12 days ago" every time you open a browser tab, it is hard to pretend you are still working on something.
The developers who finish side projects are not the ones with perfect plans. They are the ones who can see where all their projects stand at a glance.
Want a unified GitHub timeline in your browser's new tab? Try STACKFOLO on the Chrome Web Store. It is free to start, and GitHub integration works with public repos on the free tier.