Launch Is Not the Finish Line: A 7-Day and 30-Day Retrospective for Vibe-Coded Projects
Launch day is only the start. This guide walks through a day 7 and day 30 product retrospective for vibe-coded projects: setting a launch-day baseline, reading acquisition, activation, crashes, retention, paid conversion and word of mouth, and turning conclusions into keep, improve and cut lists. All example numbers come from a fictional sample product.

On launch day, you spent the whole evening staring at the screen and hitting refresh: people visited, people signed up, and someone even paid. In that moment it is easy to feel like you made it. But what decides whether a project survives is not how busy launch day was — it is what you do after launch. Launch is just the moment you hand the product to real users. A retrospective is how you turn one launch into progress for the next one.
Let me set the scope first, so you read the right article. This site already published a launch-day execution manual, which covers the checklist to work through on launch day itself, and two articles on post-incident retrospectives, which cover how to chase down the cause after something breaks. This article repeats neither of those. It covers one thing only: the product retrospective at day 7 and day 30 after launch — how the product itself performed, whether users stayed, and what to change or cut next.

The whole article follows one fictional example, so every step lands on concrete numbers. The example is "Little Recipes", a small personal product built with AI-assisted coding: you type in what is left in your fridge, and it gives you a dish you can actually cook, with steps included. All of its first-week numbers are a fictional sample, not the results of any real product: out of 1000 visitors, 400 registered — a 40% registration rate; out of those 400 registered users, 160 generated their first recipe — a 40% activation rate; out of those 160, 32 paid — a 20% conversion rate; and 30 days later, 24 of those 32 paying users were still around — a 75% retention rate. Keep this set of numbers in mind. Every section below comes back to it.
Before the retrospective, set a baseline: a snapshot of launch day
The most common way a retrospective dies is having nothing to compare against. On day 7 you open your dashboard, see that registered users went up, and feel pleased — but you have no idea whether that is good or bad, because you never wrote down what launch day looked like. So the first step of a retrospective is not looking at data. It is freezing launch day in place as a snapshot.
On the evening of launch day, spend twenty minutes writing down four things: first, how many visitors, registrations, core actions completed, and paying users you had that day; second, where the traffic came from and how much each source contributed; third, how many pieces of user feedback and error reports came in, and what they said; fourth, your own honest feeling about the product — which feature you felt least sure about, and where you expected users to get stuck. Put all four in a document titled with the launch date. It does not need to look good. It needs to be true.
Why does it have to be launch day? Because memory is unreliable. A week later, you will quietly treat your later impressions as if they were the original picture: if things went well, you will feel they were always going well; if something broke, you will feel you saw it coming. The snapshot exists to stop that self-flattery. It is the starting point of the retrospective. Without it, every "up" and "down" that follows means nothing.
For "Little Recipes", the baseline snapshot is simple: on launch day, 1000 visitors, 400 registrations, 160 people who generated their first recipe, and 32 paying users. Traffic came mostly from two places: a post the author published on social media, and a share inside a developer community. About a dozen pieces of feedback arrived that day, and the most common one was "the recipe calls for seasoning I do not have." Once that snapshot exists, the day 7 and day 30 retrospectives have an anchor: any change can be checked against it to see whether things actually got better or worse.
The day 7 retrospective: acquisition, activation, crashes, and complaints
On day 7 after launch, do not rush to talk about retention and revenue. Those numbers have not settled yet. Day 7 is for three things that sit much closer to you: where people came from, whether they did anything once they arrived, and whether the product broke at a critical moment.
Start with acquisition channels. Split the first week's 1000 visitors by source, one row per channel: how many people arrived, and how many of them registered. The judgement is straightforward: the channel whose registration rate is clearly above average deserves more of your time next month; the channel that brings many people but few registrations should not get more effort yet. For "Little Recipes", visitors from the social media post registered at close to half, while visitors from the developer community mostly clicked through to look around and rarely registered. The conclusion is not "the community is useless" — it is "the community's readers were not looking for recipes at that moment." So the next round of promotion should spend less time in developer communities and show up more in cooking and food circles.
Then look at activation. Activation means: did users do the first key thing you hoped they would do? For "Little Recipes", that key thing is generating a first recipe. In the first week, 160 out of 400 registered users did it — a 40% activation rate. The job in the retrospective is to sort the 240 who did not into groups: how many registered and never came back, how many opened the input box but never submitted it, and how many submitted but hit a generation failure. Each group calls for a different fix: people who never came back are a reminder and re-engagement problem; people who opened the box but did not submit found the input too much trouble; people who submitted and failed hit a bug in the product itself. Looking at one total tells you nothing you can act on. Split it up, and you can see where the first cut should fall.
Finally, look at crashes and complaints. On day 7, list every error report and user complaint from the week in one table, sorted by how often each one appeared. The top three are what the next version must fix. The rule is simple: the more people it affects, and the closer it sits to the core action, the higher it ranks. Compare a crash that sometimes happens while generating a recipe with an avatar that fails to upload on the settings page: the crash comes first even if it hits fewer people, because it blocks users on the way to the core action. Treat complaints the same way, and copy the user's own words instead of your paraphrase. "The recipe calls for seasoning I do not have" is far more useful than "users are unhappy with the recipes" — the first points straight at a fix: let users tick off the seasoning they already have before generating.
What day 7 should produce: three sentences
When the day 7 retrospective ends, you should have three sentences, and each one should turn directly into an action: which acquisition channel is most worth continuing; where activation gets stuck and what to change first; and the top three problems from this week. Write those three sentences down and put them somewhere you will see them. The day 7 retrospective is not about writing a beautiful report. It is about giving the second week a clear order of work.
The day 30 retrospective: retention, paid conversion, and word of mouth
By day 30, the numbers can finally say something about the longer term. The focus of the retrospective shifts from "is the product running" to "is this product worth continuing." Back to the "Little Recipes" funnel: 1000 visitors, 400 registrations, 160 people who generated their first recipe, 32 paying users, and 24 of them still there after 30 days.

Start with retention. Retention asks: of the people who paid, how many are still using the product a month later? For "Little Recipes", 24 out of 32 paying users stayed after 30 days — a 75% retention rate. The number on its own is neither good nor bad. What matters is what you compare it with: the launch-day snapshot, and the target you set for yourself. In the retrospective, look at the 24 who stayed and the 8 who left separately: what do the ones who stayed have in common — did they all use a particular feature? And when did the ones who left last open the product, and what did they do before leaving? The people who stayed tell you where the product's real value sits. The people who left tell you at which step the product lost them.
Then look at paid conversion. Out of the 160 users who completed the core action, 32 paid — a 20% conversion rate. In the retrospective, do not just stare at that ratio. Look at where paying users decided to pay: was it after generating a few recipes, or after seeing a particular paid feature? And of the 128 who did not pay, how many are happily using the free version and simply have not reached the point of needing to pay, and how many never even saw the paid feature's entry point? Those two groups need different treatment: the first group needs the right moment, the second needs a clearer entry point. Split paid conversion into three steps — "did they see it, did they want it, could they complete the purchase" — and each step has a different fix.
Finally, look at word of mouth. You do not need a brand-monitoring tool for this. For an indie developer, word of mouth hides in three places: whether users recommend the product to someone else on their own, whether anyone mentions it in public, and whether anyone is willing to write one honest sentence about it. In the retrospective, check all three: how often the referral link was opened, whether anyone mentioned "Little Recipes" on social media without being asked, and whether any paying user left a positive review. Word of mouth is not a vanity metric. It is the most direct evidence of whether the product genuinely helped someone. If retention and paid numbers look fine but nobody is willing to talk about the product, that usually means it is merely "good enough" — not yet worth mentioning.
The day 30 retrospective has one more job: go back to the three sentences from day 7 and check them off one by one. Were the top three problems from day 7 actually fixed? How did the channel you decided to keep investing in perform afterwards? Did the activation fix work? Where your judgement held up, it tells you your read was right. Where it did not, it tells you your day 7 read was off — and writing that gap down is worth more than the conclusion itself.
Turning retrospective conclusions into the next roadmap: keep, improve, cut
The easiest place for a retrospective to fall apart is at the end: pages of conclusions that never turn into what the next version should do. The way to avoid that is to force every conclusion into one of three lists: keep, improve, and cut. If a conclusion does not fit any of the three, it is not a conclusion yet — it is just an observation.
The keep list holds what is already proven to work — the parts that performed well in the day 30 retrospective. For "Little Recipes", the social media post brought a registration rate clearly above average. That is a play to keep: the next version should keep making similar content instead of trying a brand-new idea from scratch. The keep list exists to stop you from fiddling: when a product starts to gain traction, the temptation is to change the things that were working too.
The improve list holds what is proven to be broken and worth fixing, in priority order. The ordering rule is the one from earlier: the closer it sits to the core action, and the more people it affects, the higher it goes. For example, "let users tick off the seasoning they already have before generating a recipe" matches the single most common user complaint and sits on the path to activation, so it belongs at the top of the improve list. Every item on the improve list needs an acceptance check next to it: after the fix, which number will you look at, and what value counts as fixed? An improvement without an acceptance check is one you will never know worked.
The cut list is the hardest to write, and the most important. It holds the things that take up your time without bringing a matching return. Take the "Little Recipes" promotion inside the developer community: plenty of visitors arrived, but the registration rate stayed low, and both the day 7 and day 30 retrospectives pointed at the same conclusion — those readers were not looking for recipes at that moment. Cutting it does not mean it is useless forever. It means that in the next version cycle, your time has a better place to go. For an indie developer, your own time is the scarcest resource, and the cut list is how you budget it.
Once the three lists are set, the next roadmap writes itself: keep doing what is on the keep list, work through the improve list in order, and pause what is on the cut list. The roadmap does not need to be long. Three to five things per version cycle is enough. Write down more than that, and you have effectively written down nothing.
The smallest possible retrospective meeting: one person can do it
When people hear "retrospective meeting", they picture a meeting room, a whiteboard, and a few people sitting around it. But for an indie developer working alone, a retrospective meeting can be as small as one person, one sheet of paper, and one hour. The format does not matter. What matters is that it has a fixed structure — otherwise it easily turns into staring at data.
The smallest version has four steps and takes one hour. The first fifteen minutes are for numbers only: put the baseline snapshot next to the current data, compare them item by item, and write down what changed — no explaining, no defending. The second fifteen minutes are for the users' own words: read through the feedback and complaints from this period one by one, and copy out the three that appeared most often. The third fifteen minutes are for judgement: using the numbers and the quotes, write out the keep, improve, and cut lists. The last fifteen minutes are for ordering: pick the three things from the improve list that go into the next version, and write the acceptance check for each one.
There is one hard rule for this meeting: paper and pen, or a single plain-text document, for the whole hour. No opening the analytics dashboard, no scrolling social media, no answering messages. The biggest threat to a retrospective is being interrupted by new information halfway through — once that happens, the judgement never gets finished. If two or more people work on the product, stretch the hour so each person writes their own lists first and the last fifteen minutes are spent aligning them: write separately first, then compare, so one person speaking first does not pull everyone else along.
When the meeting ends, save the three lists and the three-sentence conclusion in one document whose filename carries the date. When the next retrospective starts, open the previous one first and check each item off. Do a retrospective once and it feels new. Do it three times in a row and it becomes the rhythm of how you build the product.
Common mistakes: three traps to avoid
The first trap: looking only at total visits. Total visits is the easiest number to look at, and the easiest to be fooled by. When it goes up, you feel the product is doing better; when it goes down, you feel something is wrong. But for "Little Recipes", what actually matters is each step down the funnel: 1000 visitors, 400 registrations, 160 people who generated their first recipe, 32 paying users, and 24 still there after 30 days. If total visits double while the registration rate halves, the product actually got worse. In a retrospective, always look at the funnel first and the total second.
The second trap: treating correlation as causation. On day 7 after launch, one channel brought a lot of users and its paid conversion looked good too, so it is tempting to conclude that the channel brings high-quality users. But maybe that day you simply published a particularly good post, and the people who clicked through already knew what they wanted. A channel and a conversion rate appearing together does not mean the channel caused the conversion. Before drawing a conclusion, ask one question: is there another explanation? If there is, hold the conclusion and wait for the next batch of data to check it. The value of a retrospective is in making fewer mistakes, not in reaching conclusions early.
The third trap: finishing the retrospective without an action. This is the most common trap, and the most wasteful. The meeting is done, the document is written, the three lists are made — and then nothing happens, and the next version is still built on gut feeling. The fix is unglamorous but it works: the moment the retrospective ends, break the first item on the improve list into a small task you can start right away, put it on your to-do list, and give it a deadline you can actually meet. A retrospective does not end with a document. It ends with something in the next version that has already been changed.
Before your next launch, write down the retrospective dates first
A retrospective is not damage control after launch. It is part of the launch plan. Before your next launch, mark two dates on your calendar — day 7 and day 30 after launch — and prepare the baseline snapshot template. When the dates arrive, do the work, and turn the three lists into the next version's roadmap. Keep it up for two or three cycles and you will find the biggest benefit of retrospectives is not any single conclusion. It is that you start judging your own product with the same yardstick every time — good is good, bad is bad, and you no longer have to guess by feel.
Launch is not the finish line, and neither is the retrospective. A retrospective ends when a problem has been fixed in the next version, and when the users who stayed did so because you fixed the right thing. For "Little Recipes", that is what the journey from 1000 visitors to 400 registrations, 160 first recipes, 32 paying users, and 24 people still there after 30 days is really about: seeing clearly, then changing the right thing.
Comments (0)
Related articles
You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.
One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.
Numbers in JavaScript are one type, Number, stored as 64-bit floats — which is why 0.1 + 0.2 is 0.30000000000000004. This guide follows MDN's Basic math in JavaScript, Math, and Number: one number type, float error, counting money in cents, converting strings, NaN and Infinity, safe integers, the four rounding methods, Math.random, the Math toolbox, and formatting for display.