Skip to content

Roadmap

From Code to a Product That Runs Without You

Small software, sold to people who already told you what to build

Starting point
You can build software, or can learn to, and you have no product
Where it takes you
Recurring revenue from software you own and never had to raise money for
Realistic duration
18-36 months
Capital required
No capital · $0
  1. Phase 1Months 1-6

    Get paid to learn a domain

    Goal: Be inside a real industry long enough to see what it is missing

    Stay in one industry

    • Take client work in one industry rather than whatever arrives, so the second project teaches you more than the first
    • Refuse the temptation to build a product for an industry you have only read about
    • Learn the words they use for their own work, because the wrong vocabulary marks you as an outsider in one sentence
    • Say yes to the unglamorous project in the right industry over the interesting one in the wrong one

    Collect the workarounds

    • Write down every problem the client works around with a spreadsheet, a manual process or an intern
    • Note which of those workarounds exists at more than one client, because that is the product
    • Watch someone do the work rather than asking them to describe it - the description leaves out the annoying part
    • Rank the list by how often the problem happens, not by how interesting it would be to solve

    Find out what the pain already costs

    • Ask what they already pay for and what it costs - the price of the alternative is your price
    • Work out how many hours a month the workaround eats, and what those hours cost them
    • Find out who signs off a purchase at that size, because that decides how you would sell it
    • Check whether anyone already sells a solution here - an empty market is usually empty for a reason

    Techniques in this phase

    Milestone Three projects in the same industry and one problem that appeared in all three

  2. Phase 2Months 4-10

    Ship something small enough to finish

    Goal: Complete and publish one thing, because finishing is the skill being learned here

    Cut it until it is finishable

    • Build the smallest useful version of the problem you found - a plugin, a script, a template, a single-purpose tool
    • Set a deadline in weeks and cut scope to meet it rather than moving the date
    • Write down the one thing it does, and treat every other idea as a note for later
    • Choose boring tools you already know, because the novelty belongs in the problem, not the stack

    Get it in front of them

    • Publish it where the people with that problem already are, and answer every support message yourself
    • Ship it while it still embarrasses you slightly, since the alternative is not shipping
    • Make the first run work in under five minutes, because that is how long anyone will give it
    • Write the one page that explains what it does, in their words rather than in features

    Let the requests write the next thing

    • Read what people ask for. The requests are the specification for the product that follows
    • Keep every question in one list, and notice which one you have now answered four times
    • Ask the people who tried it and stopped what they went back to
    • Fix the thing that makes people leave before adding the thing that would impress them

    Techniques in this phase

    Milestone One tool live, a hundred people using it, and a support inbox you answer personally

  3. Phase 3Months 8-16

    Charge from the first day

    Goal: Prove people pay, before building anything that takes a year

    Charge from the first day

    • Price it from day one. A free product with lots of users teaches you nothing about whether it is a business
    • Set a price you would be slightly embarrassed to say out loud, then say it
    • Charge monthly if the value recurs, and once if it does not - not the other way round
    • Raise the price for new customers as soon as three people buy without hesitating

    Sell the first ten by hand

    • Sell to ten customers by hand, one conversation at a time, before automating anything about signup
    • Set the product up for them yourself, and watch where they get stuck doing it
    • Ask each of them what nearly stopped them buying, and fix that before the eleventh
    • Do not automate a step until you have done it manually enough times to be bored by it

    Serve the people paying

    • Ship weekly to the people paying and ignore every request from those who are not
    • Do not add a second product. The first one is not finished, it is barely started
    • Tell paying customers what changed each week, because silence reads as abandonment
    • Say no to the feature that would win one large customer and complicate it for the other nine

    Techniques in this phase

    Milestone Ten customers paying every month, none of whom are friends or former clients

  4. Phase 4Months 12-24

    Solve distribution, which is the actual job

    Goal: Make new customers arrive without you finding each one

    Pick one channel

    • Pick one channel and work it for six months - search, integrations, a community, or partnerships. One, done properly
    • Choose the channel where your buyers already look for the workaround, not the one you enjoy most
    • Give it long enough to be judged, because most channels do nothing for the first three months
    • Write down what would count as it working, before you start, so you do not move the line

    Be findable where they look

    • Write the things your buyers search for while looking for the workaround they use today
    • Get listed wherever the software they already use lists compatible tools
    • Publish the comparison against the spreadsheet they use now, honestly, including where it wins
    • Ask your first ten customers what they typed to find you, and write more of that

    Grow the number that arrives without you

    • Measure how many customers arrived without you doing anything that week, and grow that number specifically
    • Track where each customer came from, from the first one, because retrofitting this is guesswork
    • Work out what one customer costs you to acquire, and what one is worth over a year
    • Stop doing the thing that brings people who never pay, however many of them there are

    Techniques in this phase

    Milestone Half of new customers arriving from a channel that keeps working when you stop

  5. Phase 5Months 24-36

    Remove yourself, or sell it

    Goal: Turn a product you operate into an asset that has value without you

    Write down what only you know

    • Write the documentation and the onboarding that answer the questions you keep answering
    • Record how a new customer gets from signup to working, and remove one step from it
    • Write down how you deploy, restore and recover, and test the restore once
    • Keep a list of every account, key and supplier the product depends on

    Hand over the interruptive parts

    • Hand over support first - it is the most interruptive and the easiest to hand over well
    • Let them answer from the documentation, and improve the documentation where they cannot
    • Set a target reply time and let the person own it, rather than checking behind them
    • Take a week away with the product running, and note everything that came back to you

    Make it valuable without you

    • Keep revenue, churn and costs in a form someone else could read in ten minutes
    • Decide honestly whether you want to run this for a decade or sell it, and get a valuation either way
    • Reduce the share of revenue coming from your largest customer, because a buyer prices that risk
    • Move accounts, domains and keys out of your personal name before anybody asks to see them

    Techniques in this phase

    Milestone A month where the product gains customers, ships fixes and handles support without you doing all three

Why this does not start with an idea

Ideas are not the constraint. Every developer has a list, and almost all of it is software for problems nobody has confirmed out loud.

Client work is unglamorous and it is the fastest legal way to be paid while looking at the inside of an industry. You see the spreadsheet holding the whole operation together, the process everyone complains about, the tool they hate but renew every year. That is worth more than any amount of ideation, and it pays while it happens.

The rule underneath the first three phases is the same one: never build anything large for a problem you have not already been paid to look at.

Distribution is the job

Most technical founders build a good product and then discover the actual work had not started yet. Software is close to free to copy, which means the hard part was never making it - it is being found by the two thousand people who would pay for it.

That is why phase four is as long as the building phases and gets its own milestone. A product with one channel that works is a business. A better product with no channel is a side project with a maintenance burden.

The channels here are slow and durable on purpose: search, integrations, partnerships, communities. Each one keeps producing customers on weeks when you do nothing, which is exactly what paid ads and posting do not do.

Where people stall

Rewriting instead of selling. The framework is wrong, the code is untidy, the design needs work - all true, and none of it is why nobody is paying.

Free forever. Ten thousand free users feels like validation and is not. Price it and find out in a week what a year of free would never tell you.

Building for developers. They are the customers you understand best, expect the most for free, and churn fastest. The unglamorous industry from phase one pays better.

Waiting for the product to be finished. It never is. The first ten customers should arrive while it is visibly incomplete, because their complaints decide what to build.

Other roadmaps