Agency by Day, Indie by Night
On March 20th, between 8 AM and 1 PM, I extracted a shared component from a monolithic location page for a national restaurant chain. Eliminated code duplication across three views, built a waitlist integration with a third-party API, and shipped a PR with 22 files changed.
That same day, between 5 PM and 6 PM, I scaffolded a SaaS from scratch — database schema, OAuth flow, webhook registration, sync engine, deployed to Vercel.
Different codebases. Different business models. Different brains.
This is what it looks like to run agency work and indie products simultaneously. Not as a transition plan, not as a "side hustle while I find my thing" — as the actual structure. Both at once, indefinitely, on purpose.
The Split
Here's what the last ten days looked like, commit by commit.
Agency side: Two client projects. One is a restaurant brand with 30+ locations — I was refactoring their location pages, building a catering CTA system, and integrating Yelp waitlist data in real time. The other is a subscription-based media company — I was fixing a login loop that had been silently locking out paying subscribers, adding GA4 tracking for their SPA, and implementing Google's paywalled content structured data for SEO.
Indie side: BusyGuard, a calendar sync SaaS I'm building under Helsky Labs. Went from empty repo to deployed product with a sync engine, dashboard, design system, webhook handling, and user settings. 66 commits in the same ten days.
The agency work is measured, careful, reviewed. PR descriptions, staging environments, E2E tests, merge queues. The indie work is fast, brutal, honest. Deploy, break, fix, deploy again. Nuclear cleanup at 6 AM because the sync engine ate my calendar overnight.
Both are real engineering. They just operate at different clock speeds.
What Agency Teaches Indie
I spent years building things the agency way before touching indie. That left marks — good ones.
Defensive coding is reflexive. When I built BusyGuard's OAuth flow, I added CSRF protection with state validation on the first pass. Not because I planned to, but because years of security reviews made it automatic. Same for input validation on API endpoints, structured logging, typed error boundaries. The restaurant chain's codebase has code review standards that would catch any of these gaps. After enough rounds of that, you stop creating the gaps.
Component architecture transfers directly. Extracting LocationActionButtons as a shared component across three views of a restaurant page is the same mental operation as extracting createGoogleProvider() as a shared factory across four sync engine consumers. The pattern recognition is identical — you see duplication, you find the seam, you extract.
Accessibility and polish aren't optional. Agency clients have real users at scale. Keyboard navigation, screen readers, ARIA labels, responsive breakpoints — these aren't nice-to-haves. After building skip-to-content links and focus trapping for agency clients, doing it for BusyGuard's dashboard was muscle memory.
The agency work trained my instincts. The indie work benefits from those instincts without paying for the process overhead.
What Indie Teaches Agency
The reverse flow is just as real, and this is the part people don't talk about.
Speed clarifies what matters. When you're shipping a SaaS alone, every abstraction has to earn its existence. I don't build a design system because it's "best practice" — I build it because I need 8 UI primitives that work together right now. That urgency bleeds back into agency work. When I'm refactoring a client's component, I'm asking "does this extraction actually save time?" not "does this look architecturally correct?"
Debugging under pressure builds intuition. At 5:34 AM, watching hundreds of phantom events multiply across calendars, I had to diagnose a production issue with no team, no Sentry dashboard, no incident channel. Just me, git log, and structured logs. That kind of debugging — where the cost of being wrong is your own product, your own users, your own morning — sharpens something that pair programming doesn't reach. When a client's login loop is locking out subscribers, I'm calm because I've been through worse on my own.
Ownership changes your relationship with code. In agency work, there's a natural distance between you and the product. It's the client's product, the client's revenue, the client's users. When it's your SaaS, every shortcut is a debt you'll personally repay. That ownership mindset leaks into agency work in subtle ways — I care more about the media company's subscriber authentication flow because I know what it feels like when your users can't log in.
The Logistics
People ask how this works practically. Some honest answers:
Context switching is real but manageable. I don't switch mid-thought. Agency work gets mornings and focused blocks. Indie work gets evenings, early mornings, and weekends. The BusyGuard timeline makes this visible — most commits are before 7 AM or after 5 PM. The nuclear cleanup at 6:15 AM wasn't dedication, it was panic. But the pattern holds.
Energy, not time, is the constraint. I have the same 24 hours as everyone else. The difference is that agency work is someone else's problems (intellectually engaging but emotionally neutral) and indie work is my own problems (emotionally loaded but deeply motivating). They draw from different wells. A full day of agency work doesn't drain me for indie work — it switches the channel. A frustrating indie debugging session doesn't affect my agency output — if anything, it makes the structured agency process feel restful by comparison.
The money question. Agency work pays the bills predictably. Indie work is an investment with uncertain returns. This is not a story about quitting your job to follow your dreams. This is a story about using stable income to fund aggressive experimentation. BusyGuard might make money. It might not. I can afford to find out because the agency side isn't going anywhere.
The Uncomfortable Truth
Here's the thing nobody in the indie hacker community wants to say: most of us don't need to quit our jobs to build products. We need to get better at doing both.
The "quit and go all in" narrative makes for good Twitter threads. It also ignores that most successful indie products were built nights-and-weekends by people who had the financial stability to iterate slowly, fail cheaply, and try again.
I'm not building BusyGuard faster because I have more time. I'm building it faster because agency work taught me when to extract a component and when to leave the duplication. When to write a test and when to ship and watch. When to refactor and when the ugly code is fine for now.
The two roles aren't competing for my attention. They're cross-training each other.
What Last Week Actually Looked Like
Monday through Wednesday morning: restaurant chain location pages. Component extraction, waitlist integration, catering CTA system. PR reviews, staging deploys, responsive testing.
Wednesday afternoon: a subscriber at the media company can't log in. Dig in, find the httpOnly cookie isn't being set on the login response. The auth middleware checks a cookie that the login endpoint never creates. Fix it, add diagnostic logging, ship to staging.
Wednesday evening: BusyGuard sync engine creates 300 phantom events overnight. Nuclear cleanup. Disable webhooks. Rebuild the sync architecture from scratch with the database as sole source of truth.
Thursday: back to the restaurant chain. Mobile spacing, catering toggle logic, PR feedback. Meanwhile, BusyGuard's rebuilt engine runs clean in the background. No duplicates. No loops.
Friday: media company's paywalled content needs Google structured data markup. Ship it. Then back to BusyGuard for user settings and dashboard visualizations.
Saturday: full indie day. Design system, activity log, sync timeline, health indicators. 66 commits since the scaffold, and the product actually works.
That's not a humble brag. That's just what it looks like. It's messy, it's tiring, and it works.
The Real Flex
Eleven years in this industry, and the most useful skill I've developed isn't React, or system design, or debugging production issues at 5 AM.
It's the ability to hold two completely different codebases in my head and switch between them without losing context. To care about a restaurant chain's waitlist UX at 10 AM and a calendar sync algorithm at 10 PM with equal intensity.
That's not a natural talent. It's a trained muscle. And the only way to train it is to actually do both.
If you're in an agency and thinking about building something on the side — don't wait for the perfect moment to go full-time indie. Start now. The skills compound in ways you won't expect.
And if you're full-time indie and wondering why you're reinventing patterns that already exist in enterprise codebases — consider a part-time agency gig. The cross-pollination is worth more than the paycheck.
Though the paycheck is nice too.