The 7-Gate Production Launch Checklist for Solo Developers
A solo launch rarely dies from a missing feature. In my experience watching one-person products ship (and in the ones I've broken myself), it dies from one of three things β and all three are testable in an afternoon:
A solo launch rarely dies from a missing feature. In my experience watching one-person products ship (and in the ones I've broken myself), it dies from one of three things β and all three are testable in an afternoon:
- Silent data loss. A migration runs, a column changes type, a default overwrites production rows. The first sign of trouble is a user saying "my project is empty." Nobody notices for nine hours because nothing throws an error.
- A payment path that works for you and not for a stranger. You tested with your own card, your own account, and an admin flag that quietly bypassed the one check the real flow hits. Money moves, the webhook fires twice, the receipt goes out three times.
- No idea what broke. The first support email arrives. You open the app, it looks fine, and you have no error tracking and no way to reproduce what one person saw.
Every gate below exists to catch one of those three before a stranger finds it for you.
What a gate is
A gate is a check with a written exit criterion and an artifact that proves it passed. Not a feeling. Not "it worked when I tried it." An artifact:
- a restore of last night's backup into a scratch database, with a row count you can quote
- a log line from the smoke test showing
POST /checkout 200for a fresh account - the URL of a test transaction in the payment provider's dashboard
- a screenshot of staging rendering the same page as production
If you cannot point at the artifact, the gate is open and the launch is a bet.
The seven gates
| Gate | Question it answers | Exit artifact |
|---|---|---|
| 1. Scope | Is the thing I'm launching exactly the thing I tested? | One-page launch scope, frozen |
| 2. Environment | Is production the same shape as what I tested? | Env audit with every key checked |
| 3. Data | Can I get back to this exact state if it goes wrong? | Restore drill log with row counts |
| 4. Smoke | Does a stranger get from signup to value without help? | 12 passing paths on a fresh account |
| 5. Observability | Will I know within five minutes if it breaks? | Error tracker + uptime alert proven |
| 6. Comms | Do I sound like a person when it breaks? | Three message templates, written |
| 7. Decision | Have I written down what would make me roll back? | Rollback thresholds, with numbers |
Gates 1β5 and 7 are blocking. Gate 6 is soft only because a broken launch with no comms template still launches β it just hurts more.
Gate 1: freezing scope is a technical act
"Freeze the scope" sounds like project management. It is actually a testing requirement: you can only test a fixed set of behaviour, and every feature you add after the smoke pass invalidates part of that pass.
The rule I use is mechanical: from the moment the second full smoke pass starts (T-1), the deployable artifact changes only for security fixes, data-loss fixes, and the launch checklist itself. Anything else is a commit on a branch, merged after launch.
Write the freeze as one page you can check a build against: what ships (3β7 user-visible capabilities, each with one sentence and one URL), what explicitly does not ship, who can use it, what it costs, and what "working" means β the single number you will check on day seven. A launch scope without a success number becomes a launch you cannot evaluate.
Gate 2: production is a different computer
Every "it works locally" story is a story about a difference. The audit's job is to find the differences on purpose, before a stranger finds them by accident.
For each variable and key, capture five things: name, purpose, where it is set, whether staging has the same value, and when it was last rotated. Then follow the rules that prevent the usual damage:
-
Same names everywhere.
STRIPE_KEYin staging andSTRIPE_SECRET_KEYin production is a bug waiting for a copy-paste. -
No defaults for secrets.
os.getenv("SECRET_KEY", "dev")is a production vulnerability with a friendly face. Fail at boot instead. -
One source of truth. If a value exists both in the host dashboard and in a
.envon the box, you no longer know which one is live.
The highest-value ten minutes of the whole audit is the test-key search: grep production config for sk_test, sandbox, localhost, 127.0.0.1, :3000, example.com, changeme. A payment provider left in test mode is invisible for days β the page looks fine, nobody can pay.
# Fail fast, loudly, and name what is missing β never print values.
REQUIRED = ["DATABASE_URL", "STRIPE_SECRET_KEY", "SESSION_SECRET", "SMTP_URL"]
def check_boot_config(env):
missing = [k for k in REQUIRED if not env.get(k) or env[k].startswith("changeme")]
if missing:
raise SystemExit(f"Refusing to start. Missing config: {', '.join(missing)}")
A deploy that crashes in ten seconds is infinitely better than one that serves 500s for an hour.
Also check the boring, cheap, catastrophic things: apex domain resolves as well as www, the certificate covers both, and there is exactly one HTTPS redirect hop. Lower the TTL on records you might change to 300 seconds 48 hours before launch. If your domain sends mail, confirm SPF, DKIM and DMARC before the first launch email β that email is often the first your domain has ever sent, and it lands in spam.
Gate 3: you have not tested your backups
A backup file that has never been restored is a rumour. The only claim you can make with confidence at launch is: I restored last night's backup into a scratch database and counted the rows.
The drill takes twenty minutes:
- Take a fresh backup. Note timestamp and size.
- Create a scratch database β a free tier, a container, anything not production.
- Restore into it. Time the restore.
- Run
count(*)on the three tables that would ruin you to lose: users, payments, and whatever holds the customer's work. - Compare against production. The counts should be within one write of each other.
- Open the app against the restored copy and load one real record.
- Write down: backup timestamp, restore duration, row counts, any error.
A restore that takes 90 minutes is not an emergency plan, it is an outage with a schedule β and knowing that in advance changes how you launch.
The other half of data safety is the expandβcontract pattern, the single most useful discipline for one-person teams. Split every risky schema change into three releases: expand (add the new column, nullable, nothing reads it yet), backfill and switch (write both, read new, flip back by changing one line), contract (drop the old column a week later). At every point the previous release still works, which is what makes a rollback a redeploy instead of a restore.
And keep an irreversible list: dropping a column, rewriting values in place, deleting storage objects, rotating a key whose old value is still in use, sending an email you cannot recall. If the list is not empty, either split the release or write down explicitly why you accepted it.
Gate 4: twelve paths, run like a stranger
Unit tests prove functions behave. Smoke tests prove a person can get from the front door to value without help β and on launch day the second one is what matters.
Three properties make a smoke suite useful: it is twelve paths, not two hundred (fast enough to run three times in the last two days); it runs in the same conditions as the stranger (fresh account, private window, phone viewport, no admin flag, real network); and it is recorded with a timestamp and the conditions β "pass, 14:20, private window, phone, cellular" is evidence.
The twelve paths, chosen because they are where solo products break for someone else while working for their author:
- Landing β signup (email validation, double-submit)
- Email confirmation link (wrong host, expired token, logged-out window)
- Login and logout (cookie domain, same-site flags, redirect loop)
- Password reset (deliverability, token reuse)
- The core action (permissions, empty state, first-run data)
- Payment / checkout (test key, currency, tax, decline path)
- Webhook β entitlement (signature check, idempotency)
- Receipt and invoice (arrives once, correct amount, downloadable)
- Cancel / refund / downgrade
- Account deletion and export (orphaned rows, storage leftovers)
- Mobile layout on a throttled connection (375 px, 3G)
- Recovery after a restart (in-memory state, lost queues, cold start)
Path 7 is the one most often faked. A webhook that fires correctly once is not the same as an endpoint that is idempotent, signature-checked and tolerant of out-of-order delivery. Replay it twice and confirm the second delivery changes nothing.
Conditions that produce false passes, and what to do instead:
| False pass | What hid it | Do instead |
|---|---|---|
| Cached assets | Browser served yesterday's bundle | Private window, cache disabled |
| Admin override | Owner role skipped the paywall | Fresh account, no role |
| Local environment | App pointed at localhost | Run against the production URL |
| Warm connection | DNS and TLS already resolved | Test from a phone on cellular |
| Only the happy path | Nobody tried declining or cancelling | Add the failure variants |
| Only desktop | Fixed-width layout | 375 px viewport |
Add a column to your checklist notes called conditions. "Pass β private window, fresh account, 5G" is worth ten times "pass".
Gate 5: know within five minutes, without looking
Set the standard in one sentence: if the site breaks, you know within five minutes without looking at it.
If you install only two things before launch, install error tracking and one uptime check β then force both to fire, so you know the path from failure to your phone actually works. That round trip, from your deliberate error to your screen, is the artifact.
Two settings matter more than the rest: environment tagging (without it, staging errors page you at 2am) and noise filters (an error tracker that sends forty notifications a day gets muted in week two, and then it is not monitoring at all).
Check the URL a customer actually uses, not /health on the internal port. A health endpoint that returns 200 while the database is down is worse than no check, because it reports green through an outage:
GET /api/health -> 200 {"ok":true,"db":"up","version":"1.4.2"}
Have the health check do a one-row read against the database and return non-200 when it fails. That is the difference between "the server is running" and "the product works".
And keep an alert budget: maximum three alerts before launch (site down, error rate above threshold, one business counter at zero). Every alert must be actionable at 2am, and every alert needs one line written next to it: if this fires, do X. An alert without a written response is a notification, and notifications get ignored.
Gate 6: three messages, written before you need them
Most launch pain is not technical. It is a vague message arriving at the worst possible moment, and you composing a reply while you are also debugging. Write the three messages before launch, so on the day you paste instead of think:
- Acknowledgement, within 30 minutes. What is affected, that you are on it, and when you will update next. No cause, no excuse, no promise of a fix time: "Checkout is failing for some customers. I am investigating and will update here within 30 minutes."
- Update, every 30-60 minutes. What you know, what you tried, what is next. "No progress" is a valid update. Silence is not.
- Resolution. What happened, who was affected, and what changed so it cannot happen again.
And when a bug report is vague, answer with structure: acknowledge it, ask the two questions that make it reproducible (what did you click right before it happened, and roughly what time it was), and commit to a time you can actually meet. Then keep that time, even if the answer is "not fixed yet, here is what I know."
Gate 7: rollback thresholds, written before you need them
On launch day you will be too close to judge. Decide now, in writing, with numbers:
| Condition | Action | Who decides |
|---|---|---|
| Site unreachable > 5 minutes | Roll back to previous release | You, immediately |
| Error rate > 10% for 5 minutes | Roll back | You, immediately |
| Data loss of any kind | Stop writes, snapshot, investigate | You, immediately |
| Checkout fails for > 3 users | Roll back the checkout change only | You, within 15 min |
| Slow but working (p95 > 5s) | Fix forward in 2 hours, or roll back | You, judgement |
| Cosmetic or copy issue | Fix tomorrow | Nobody |
Solo means the authority is never in question β only the threshold.
Before launch, answer this on paper: if I roll back this deploy, does the database still work with the old code? If the answer is no, your only path is forward, and you should know that before you press the button rather than discover it at T+40.
The five go/no-go questions
Ask these out loud, in this order, in the last hour before you press launch. Any "no" is a delay, not a discussion.
- Can I restore the database to this morning's state, and have I done it this week?
- Does a brand-new account reach the paid outcome without me touching anything?
- Will I know within five minutes if the site stops working, without looking at it?
- Do I know exactly what I will do in the first ten minutes after something breaks?
- Is there anything in this deploy I cannot undo?
Question 5 is the one that gets skipped and the one that costs the most.
The 90-minute version
For a small launch β a landing page with a checkout, a small tool, a first paid tier β this is the minimum defensible pass. Twelve checks, ninety minutes, no gate skipped entirely:
- Freeze the scope in one sentence; everything else goes in
after-launch.md(5 min) - List every production env var and confirm each exists in staging (15 min)
- Confirm no test key is live β payment, email, AI, storage (10 min)
- Take a backup, restore it into a scratch database, count the three tables you care about (20 min)
- Run the money path with a real card in test mode, from a brand-new account, on a phone, no admin flag (10 min)
- Check the receipt and the email actually arrive, once, at the right address (5 min)
- Install error tracking and force an error in production to see it arrive (10 min)
- Set one uptime check on the URL that matters, alerting your phone (5 min)
- Write three messages: "we are aware", "here is what we know", "it is fixed" (5 min)
- Write two rollback thresholds with numbers in them (5 min)
- Test password reset and account deletion end to end (5 min)
- Post the launch to five people first, not five hundred (5 min)
If you only do one of these, do number 4. A launch with a tested restore is a bad afternoon at worst. A launch without one is a company-ending event that happens slowly.
Where this list comes from
This is the shape of a 30-page runbook I put together for one-person launches β seven gates, 63 checks and 13 editable files (checklist CSV, env audit, gate map, smoke-test plan and script, restore drill, migration/rollback plan, launch-day script, incident comms templates, week-one review). It is $7 here if you want the fill-in-the-blank version instead of rebuilding it: The Solo Launch Runbook.
If you are freelancing rather than shipping a product, the free starter pack is probably the better first download β ten AI prompts for proposals, scoping and client updates: 10 Essential AI Prompts for Freelancers (free).
Either way: write the artifact down. A checklist you have not marked up is a wish list, and a launch you cannot point at evidence for is a bet.
Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.