There are two failure modes for solo founder roadmaps. The first is no roadmap at all: everything lives in your head, or scattered across sticky notes and random Notion pages, and you wake up each morning deciding what to work on based on vibes. The second is an over-engineered Gantt chart with dependencies, deadlines, and swimlanes that takes longer to maintain than the actual building.
Both lead to the same place. You end up working on whatever feels urgent instead of whatever matters most.
The framework that actually works for solo founders is simple: Now, Next, and Later.
What Now/Next/Later means
Now is what you're working on this week. One, maybe two things per project. These are active, in-progress, you're building them right now. If someone asks "what are you working on?", the answer is whatever's in Now.
Next is what's coming up. The things you'll probably pick up in the next couple of weeks once your current work is done. They're defined enough to start soon, but you haven't committed to them yet.
Later is the parking lot. Good ideas, feature requests, things you want to build eventually. No timeline, no commitment. They're captured so you don't forget them, but they're not competing for your attention today.
That's it. Three columns. No dates. No dependencies. No Gantt charts.
Why it works for solo founders
Traditional roadmaps assume you have a team. Gantt charts make sense when multiple people are working in parallel and you need to coordinate dependencies. Sprint planning makes sense when you have a product manager, designers, and engineers who need to align on two-week cycles. Quarterly OKRs make sense when departments need to synchronise.
You're one person. You don't need coordination. You need clarity.
Now/Next/Later gives you clarity with almost zero overhead. You look at the board, you know what you're doing today, you know what's coming next, and you know the ideas are captured for later. No maintenance burden. No status meetings with yourself. No updating a Gantt chart every time something takes a day longer than expected.
It also handles interruptions well. Customer reports a critical bug? Move something from Now to Next, drop the bug fix into Now. Priorities changed because a competitor launched something? Reshuffle. The framework is fluid because the categories are relative, not absolute.
The portfolio roadmap problem
This framework gets even more valuable when you're running multiple projects. If each project has its own separate backlog, you're constantly context-switching between different lists trying to figure out where to spend your time.
A portfolio-level roadmap puts everything on one board. Now has three items: one from Project A, two from Project B. Next has items from all three projects. You can see at a glance where your time is going and whether the balance is right.
This is where most tools fall down. Issue trackers like Linear and GitHub are built for single projects. You can have multiple workspaces, but there's no unified view across all of them. You end up with three separate backlogs and no easy way to prioritise across them.
What you want is a roadmap that spans your portfolio. All projects, one board, Now/Next/Later. You should be able to see "these are the three things I'm actively building right now across everything" in one place.
How to decide what goes where
The hardest part isn't the framework. It's deciding what belongs in Now versus Next versus Later.
A few heuristics that work:
Now should be small. Two to three items maximum across all your projects. If you have eight things in Now, you effectively have zero things in Now, because you'll spend all day deciding which of the eight to work on. Constraints are productive. Force yourself to pick.
Next should be ready. Items in Next should be defined well enough that you could start them tomorrow if Now cleared out. If an item in Next is still vague ("maybe improve the onboarding somehow?"), it belongs in Later until you've thought it through.
Later is for capture, not commitment. The whole point of Later is that you don't have to think about it. A user requests a feature? Later. You have an idea in the shower? Later. Your competitor ships something cool? Later. It's captured. It's not lost. But it's not pulling at your attention.
Move things forward deliberately. When you finish something in Now, pull the highest-priority item from Next to replace it. When you're planning your week, review Next and decide if anything should move to Now. Periodically scan Later and promote anything that's become more urgent or important.
Breaking items into work
A roadmap item like "add Stripe integration" is too vague to build from. It needs to be broken into actual work items: set up Stripe SDK, create webhook handler, build subscription management UI, add billing portal link, write tests.
This breakdown is where planning turns into execution. Each work item should be small enough to complete in a sitting. If a work item feels like it would take more than a few hours, it's probably two or three items pretending to be one.
The breakdown also makes delegation possible. If you're using AI coding agents, a well-scoped work item with clear context ("add a webhook handler for Stripe subscription events, using the existing StripeService class, with Pest tests") is something an agent can actually execute. A vague roadmap item ("add Stripe integration") is not.
Don't lose the ideas
The biggest risk with any planning system is good ideas falling through the cracks. You're deep in Project B, shipping a feature, and you suddenly think of a perfect improvement for Project A. Where does that go?
If it goes into a separate note, a different app, or just stays in your head, it's lost. Maybe not today, but eventually.
It needs to go into the same system as everything else. Drop it into Later for Project A. Two seconds. It's captured. You'll see it next time you review the roadmap. Move on with your day.
This is also why a unified view across projects matters. If your Project A roadmap lives in one tool and Project B lives in another, capturing a cross-project idea means opening a different app and losing your flow. If everything's on one board, it's a quick add and you're back to work.
What we built for this
Roadmap planning across projects is one of the core features of Shipchart. Each project has a Now/Next/Later board, and there's a portfolio view that shows items across all your projects on one screen.
Roadmap items break down into nested work items with inline descriptions, drag-to-reorder, and the ability to push them to Linear or GitHub Issues when you're ready to build. The AI tools can generate work items from a feature description, challenge your plan with structured critique, and review completeness to catch things you missed.
There's also a public roadmap feature if you want to share what's coming with your users. Give them a URL and they can see the Now/Next/Later board for your product. Transparency without extra work.
Free tier is available. But regardless of what tool you use, the framework is the important part. Three columns. Ruthless prioritisation of Now. Everything captured in one place. That's it.
The short version
Stop over-engineering your roadmap. You don't need Gantt charts, sprint cycles, or quarterly planning ceremonies. You need three buckets: what you're doing now, what's next, and everything else. Keep Now small, keep Next ready, and use Later as a guilt-free parking lot for good ideas. Review it weekly. One board across all your projects. That's the whole system.