How to manage a portfolio of side projects without dropping the ball

Running a portfolio of small apps is one of the best positions an indie founder can be in. Instead of betting everything on a single idea, you spread your risk across several. If one takes off, you're set; if one dies, you've lost a corner of your time, not your livelihood. The optionality is real and the upside is asymmetric. But there's a quiet trap on the other side of that appeal, and most portfolio founders walk straight into it.

The appeal and the trap of running many apps

The appeal is obvious: more shots on goal, more surface area for luck, more ways to learn. The trap is subtler. When you run five projects, each one moves at one-fifth the speed. Momentum is the single most important force in an early-stage app, and a portfolio dilutes it by default. You end up with a collection of half-finished, half-marketed apps — each promising, none breaking through — because none of them ever got the concentrated push that turns a promising app into a real one.

So the goal isn't to run fewer projects. It's to run several without letting any of them rot, while still giving one or two the deep focus they need to grow. That requires a system, because instinct will fail you: instinct pulls you toward whatever is newest, loudest, or most fun to build today — which is almost never the thing that deserves your attention.

The real cost of context-switching

Every time you jump from one project to another, you pay a tax. You have to reload the codebase in your head, remember where you left off, recall the half-formed decision you never wrote down. That reload isn't free — it can eat twenty or thirty minutes before you're productive, and it drains the mental energy you'd rather spend on hard problems. Do it five times a day across five apps and you've spent your best hours just remembering what you were doing.

This is why 'a little bit of everything, every day' is the worst possible schedule for a portfolio founder. It maximizes switching and minimizes the depth any single project gets. The apps feel busy but never advance, because you never stay in one long enough to make real progress. The fix is to switch less, not more — and to be deliberate about when you switch.

Progress on a portfolio comes from depth on one project at a time, rotated deliberately — not breadth spread thin across all of them at once.

Limit your work-in-progress

Borrow the most useful idea from lean manufacturing: cap your work-in-progress. At any given time, only one or two projects should be in active focus — receiving real, deep, feature-building attention. Everything else sits in maintenance mode: alive, monitored, and getting small upkeep tasks, but not competing for your creative energy. The number of projects you own can be large. The number you're actively pushing must be small.

What each mode looks like

• Active focus: one or two projects getting deep-work sprints — new features, meaningful marketing pushes, the work that creates momentum.
• Maintenance mode: everything else — bug fixes, replying to users, a single small task to keep it breathing and not fall out of your head.
• Parked: projects you've deliberately paused, with a note on what would need to be true to reactivate them.
• Sunset: projects you've decided to wind down, so they stop taking up mental space entirely.

Putting a project in maintenance mode isn't neglect — it's a decision. The difference between a maintained project and a neglected one is that you chose the first. A neglected project rots because you forgot about it; a maintained one keeps ticking because you gave it a small, defined job.

How to decide which project gets attention this week

If only one or two projects get deep focus, the highest-stakes decision you make each week is which ones. Don't leave it to mood. Score your candidates against three questions, and the answer usually becomes obvious.

1. Traction: which project is showing signs of life — signups climbing, users returning, revenue ticking up? Momentum compounds, so feed the thing that's already moving.
2. Leverage: where will a focused week produce the biggest result? Sometimes a stalled project is one feature or one marketing push away from working — that's high leverage.
3. Milestone stage: is a project close to a meaningful finish line — a launch, a paying customer, a feature that unblocks everything else? Nearly-done work deserves a push to get it across the line rather than sitting at 90%.

Usually one project wins on two of the three, and that's your focus for the week. The others drop to maintenance without guilt, because you know they'll get their turn and you have a system that won't let them disappear. The point isn't to be right every week — it's to choose on purpose instead of drifting toward whatever feels urgent.

A lightweight weekly review ritual

The one habit that holds a portfolio together is a short weekly review. Not an hour-long planning session — five to ten minutes, same time each week, where you look at every project at once and make three small decisions. This is the ritual that catches the project silently sliding toward death before it's too late to save.

1. Scan every project's status and last activity. Anything that hasn't moved in weeks gets flagged — either give it a task or admit you've parked it.
2. Pick this week's focus using traction, leverage, and milestone stage.
3. Set the single next task for every other project so maintenance mode has something concrete, not a vague intention.

The value here is visibility. Most projects don't die from a bad decision; they die from an absence of decisions — from never being looked at until they're too stale to revive. Seeing every project's progress and its next task in one place, once a week, is what prevents that. This is exactly the kind of single-pane view shipsolo is built to give you: every project, its status, and the next action, side by side.

Small tasks vs. deep focus sprints

Keeping a portfolio moving takes two different kinds of work, and confusing them is where founders go wrong. Deep focus sprints are for the active-focus project: multi-hour blocks of concentrated building, ideally several days in a row on the same thing, where momentum builds and hard problems get solved. This is where breakthroughs happen, and it only works when you protect the time and resist switching.

Small tasks are for everything else. A maintenance-mode project doesn't need a sprint — it needs one ten-minute task to stay alive: answer a support email, ship a small fix, post an update. These fit in the cracks of your day and cost almost nothing, but they keep a project warm so that when its week comes, you're not restarting from a cold, forgotten codebase.

When to sunset a project

The hardest and most valuable skill in portfolio management is killing things. Every project you keep on life support is a small, permanent tax on your attention — a line you scan, a decision you defer, a bit of guilt you carry. A project that has had a genuine, focused shot and stayed flat isn't optionality anymore; it's a drag. Sunsetting it is not failure. It's freeing the attention that makes your other projects succeed.

A project is a candidate for sunset when it has had at least one real week of deep focus, the market has told you no with silence or churn, and you no longer feel the pull to work on it. Give it a clean ending: tell any users, keep it running if it's cheap and harmless, and archive it in your system so it stops occupying a slot in your head. Then put that freed-up focus somewhere with a pulse.

Use one shared system so nothing rots

Everything above depends on one thing: seeing your whole portfolio in a single place. If each project lives in its own scattered notes, README, or half-remembered mental list, you can't run a weekly review, you can't compare traction, and projects rot in the gaps between tools. The scattering is what kills them — not any single missed task, but the absence of a place where every project's state is visible at once.

So keep every project in one shared system — one view where you can see each app's status, its momentum, and its single next task, and rotate your deep focus without dropping any of them. That's the whole discipline of managing a portfolio of side projects: not more hours, but less switching, deliberate focus, and one place where nothing gets forgotten. Do that, and a portfolio stops being a pile of stalled apps and starts being what it promised — several shots on goal, each still moving.