Skip to content
← Back to writing

March 20, 2026

What 12 Scrum teams taught me about building alone

Sprint planning, story points, and retrospectives work solo. The skills that got me hired are the same ones making me dangerous building on my own.

The enterprise background

I don't have screenshots of the old corporate boards, so here's the discipline in its current form: the real pre-commit hook on my own repo, live, blocking a source edit on main because the branch carries no ticket key.

At Neptune Technology Group (a $6B industrial tech company) I managed twelve Scrum teams at once. PSM I certified, CSPO, SAFe 6 Agilist. I ran sprint planning for teams building IoT water metering infrastructure. I kept Jira boards with 800+ issues in flight, tracked velocity across twelve codebases, and reported delivery forecasts to leadership.

The job was hard in a way that's tough to explain to people who haven't done it. Twelve teams meant twelve backlogs, twelve velocity curves, twelve sets of stakeholder priorities. The dependencies were the real work: one team's sprint slipping could cascade into three other teams' timelines. I spent all day holding a graph in my head of who was blocked on what, and where the critical path actually ran.

When I left I assumed those skills were useless outside a corporate team. I was wrong. I'm still applying for roles while building on my own, and the same muscle memory carries both.

Sprint planning for one

I run two-week sprints for myself. Without a sprint boundary, I context-switch between three products until nothing ships. The boundary is the thing that makes me finish.

Every other Monday I do sprint planning. I pull from the backlog in my task tracker, estimate story points, and commit to a one-sentence sprint goal: "Ship the HomelabARR PE storage layer," or "Get NeuroHelper to beta," or "Finish the LemonSqueezy checkout integration."

The sprint goal does the same job it did in enterprise. It forces focus. When I'm tempted to start a new feature on a different product, the goal reminds me what I already committed to. That tension between what's novel and what's committed is most of the discipline.

Story points still work too. I use a simplified scale: 1 (trivial), 2 (a few hours), 3 (a day), 5 (multiple days), 8 (a full sprint). My solo velocity averages about 20 points a sprint. Load 30 and I'm overcommitting; load 12 and I'm sandbagging, and the estimate is a guardrail against lying to myself.

Retrospectives with an AI

Every other Friday I sit down and run a retrospective with Imogen.

It sounds absurd, but it works. I tell her what went well, what didn't, and what I want to change, and she pushes back. She reminds me of patterns I've repeated. She'll say things like "You said you'd stop doing late-night deploys three sprints ago. You did two this sprint."

The format is the same three questions it always was:

  • What went well: shipped the landing page, got the multi-agent system stable, customer support response time under 2 hours.
  • What didn't: spent too much time on a feature that didn't matter, got distracted by a homelab project mid-sprint, didn't write tests for the billing integration.
  • What I'll change: time-box exploration to 2 hours, no homelab changes during a sprint, and tests before merge.

Imogen logs the action items and checks on them at the next retro. She's a better accountability partner than most humans because she never forgets and she doesn't get tired of reminding me.

Backlog grooming is product strategy

In enterprise, backlog grooming was a team activity. Solo, it's the most important hour of my week. Every Monday morning I look at the backlog across all three products and ask three things: what generates revenue, what unblocks revenue, and what's interesting but not urgent.

Revenue work gets priority, always. The unblockers come second: infrastructure, billing integration, landing pages. Everything interesting-but-not-urgent goes to the bottom, and that's the pile I'm most tempted by. Those items don't pay the bills, so they wait. The grooming discipline is the only thing that stops me from building the most interesting thing instead of the thing that matters. I still build the interesting things, I just do it after the revenue work ships.

Definition of done

In enterprise the Definition of Done meant code review, QA sign-off, documentation updates, and stakeholder approval. Solo, mine is shorter but no looser:

  • Code is committed and pushed
  • It works in production, not just locally
  • A real user could use it without asking me for help
  • It doesn't break anything else

"Works on my machine" isn't done, and neither is "I tested the happy path." Done means a stranger could find it, use it, and not hit an error. That bar is what keeps me from calling something shipped when it's only pushed to main.

Lately I've stopped trusting myself to remember the bar, so I moved it into the tooling. The same Jira workflow I ran across twelve teams now runs on me. Tickets carry a Definition of Ready before they leave the backlog (a user story, acceptance criteria, story points, an epic link) and a Definition of Done before they close. The gates aren't documentation anymore. A pre-commit hook checks the git branch for a ticket key and blocks the edit if I'm on main or a keyless branch, so I physically can't write code that isn't tied to a ticket. The process I used to enforce in stand-ups now enforces itself with an exit code.

The velocity chart doesn't lie

I track velocity in a simple dashboard, and the recent sprints tell one story. Sprints where I focused on a single product shipped 25+ points. Sprints where I bounced between three products shipped 10 to 12. The Scrum Guide always said focus is the biggest predictor of delivery, and my own chart agrees.

It shows one more thing. My velocity dips after I skip a retrospective. Without the retro, the bad habits compound: late-night deploys come back, tests get skipped, "I'll fix that later" creeps back in. The retro resets the discipline, and skipping it lets that discipline erode inside a single sprint.

What transfers, what doesn't

What transfers perfectly: sprint planning, backlog grooming, retrospectives, story points, Definition of Done, velocity tracking, sprint goals.

What doesn't transfer: daily standups (useless alone), sprint reviews with stakeholders (I am the stakeholder), SAFe PI planning (overkill for one person), formal estimation ceremonies (I know my own velocity).

The core Scrum practices are tools for focus and accountability, and that holds at any team size. What doesn't survive is the ceremony: the meetings, the formality, the process overhead that only exists to coordinate multiple humans. Strip that away and you keep the skeleton, and for one person the skeleton does the whole job.

The PM advantage

The hardest part of building a company is deciding what to build, in what order, and what to cut, not writing the code. That's project management, and it's the skill I spent a decade developing.

AI writes the code now, and it's good at it. What it can't do is look at three products and decide which feature ships this sprint. It can't weigh customer feedback against runway against technical debt against how much energy I have left this week. It can't tell the difference between "this is hard and I should push through" and "this is hard because it's the wrong approach."

Those are human judgment calls. They're the same calls I made managing twelve Scrum teams, just at a different scale.

Imogen Labs