Back to Explore
GuideVibeFix editorialUpdated Nov 15, 2026

After the Crash, Don't Just Say Sorry: Crash Recovery for Your Vibe Project

Users don't hate one crash — they hate redoing work the crash erased. This guide covers autosave, reopening where they left off, asking consent for crash reports, and safe mode for repeat crashes. All example projects, people, and numbers in this guide are fictional.

A woman sits on a sofa frowning at the phone in her hand, her other hand raised in frustration at something going wrong on screen

Zhou Zhou was queuing at the supermarket checkout, one person ahead of her. She opened "Ledger Cat" to log the groceries she had just bought: greens for 12, eggs for 18, pork ribs for 46. She was halfway through the second entry when the screen went black — the app had crashed back to the home screen. She stared for two seconds, reopened the app, and found a clean home page. Neither of the two entries she had typed was there. Standing at the till with people waiting behind her and the groceries still unpacked in the cart, she retyped all three entries from memory — and could no longer remember whether the eggs were 18 or 16. When she got home she deleted "Ledger Cat" and switched to another budgeting app. Not because it had crashed once, but because after the crash, her work was gone for nothing.

Two things to make clear first. First, the walkthrough project "Ledger Cat", the operator "A-Miao", the user "Zhou Zhou", and every time and number in this guide are fictional, invented only to make the process concrete. Second, the boundary: this site has already published several guides about errors — "Your Users Saw a White Screen Before You Did: Error Monitoring and Crash Reporting for Vibe Projects" is about finding out that the app crashed as soon as it happens, a question of how the developer knows; the error-tracking guide is about collecting errors to find their cause, a question of how to investigate; the error-and-empty-states guide is about what the screen says in the moment, a question of what to say right then; the backup guide and the database-backup-and-disaster-recovery guide are about how server-side data gets backed up, a question of how to get lost data back. This guide repeats none of them. It covers one thing only: after the app has already crashed in a user's hands, how to keep the user's work safe and bring the person back. Monitoring governs "knowing it crashed"; recovery governs "what the user does after it crashed." They are different jobs.

A woman sits on a sofa frowning at the phone in her hand, her other hand raised in frustration at something going wrong on screen

1. First, the reality: users do not hate the crash, they hate the wasted work

Many teams panic at the word "crash rate," assuming that if they just fix every crash, users will stay. That is only half right: no matter how clean the fixes, the rate never reaches zero. There are thousands of phone models, system versions vary, memory fills up without warning — every app will crash on somebody's phone someday. What users really hate is not "it crashed once." It is "after it crashed, what I was just doing is gone, and I have to start over." Zhou Zhou's three half-typed entries were not three lines of numbers; they were two minutes of her time at the checkout, squeezed out while queuing with people behind her, wasted for nothing. One wasted effort outweighs ten small stutters.

The fictional numbers in this guide are: of 100 crashes, autosave kept the user's half-finished work safe in 86, the app reopened straight onto the screen where it crashed in 71, users finished the task without redoing anything in 58, and in 41 the user later said they would keep using the app. These numbers are fictional, and they make one point: crash recovery is also a funnel, and people drop out at every step. Only 86 out of 100 kept the work, so recovery first has to solve "is the stuff still there"; 71 got back to where they were, so it also has to solve "can the person get back"; only 41 said they would stay, so it also has to solve "do they still trust you." Skimp on any step and the funnel leaks right there.

Here is another fictional comparison: when the crash-report prompt used the system default — "Send crash report?" — only 19 out of 100 people agreed; when it was rewritten in plain words — "The app just crashed. Send us the error details so we can fix it? It doesn't include your ledger. Is that okay?" — 63 out of 100 agreed. The numbers are fictional — the point is not 19 and 63 themselves, but that users are not unwilling to help; they simply did not understand what was being asked. The first rule of crash recovery is that simple: a crash is a technical problem, but recovery is a trust problem — the fix repairs the crash, the recovery repairs whether the user is willing to come back.

2. Two kinds of crash: a crash-out and a freeze need different recoveries

Before building recovery, separate the two kinds of crash, because they need different handling. The first is a crash-out: the app suddenly disappears, back to the home screen. What the user sees is "the app is gone," and what they think is "is what I was doing still there?" The second is a freeze: the app is still on screen, but nothing responds, or a spinner spins forever. What the user sees is "the app is alive but stuck," and what they think is "will it get better if I wait?" Different crashes, different moods, different jobs for the product.

For a crash-out, the core job is "the stuff is still there." Every time the app exits — the user closing it, the system killing it, or it crashing — it should leave the scene as if the user might come back at any moment. The way to do that is to save at every step: finish typing one entry and it is stored locally at once; a half-written note is saved every few keystrokes; the filters chosen and the list position reached are recorded on exit. Saving must be fast and silent — no "Saved!" popup every time. Users do not need to know you saved; they only need to find everything still there when they return. The fictional number in this guide is that the app returns to the pre-crash screen within 3 seconds of reopening. The number is fictional; the point is "fast enough that the user feels no break" — come back slowly, and the user assumes everything is lost and panics first.

For a freeze, the core job is "give them something to hope for." When an app is stuck, what users fear most is not waiting — it is not knowing how long the wait is, or whether waiting will help at all. The fix is to say something clear first: after 3 seconds of no response, the screen should say in plain words, "A bit stuck — still loading, hang on a moment"; after 10 seconds with nothing, offer two choices: "Wait a little longer" or "Restart the app — what you were doing is already saved." The worst thing to do is say nothing and leave the user staring at a spinner — after 10 seconds of nothing, they will kill the process themselves, and killing it can genuinely lose the scene. When the app freezes, the product should speak first: "We know it's stuck, your stuff is saved, wait if you like, restart if you like." Give users a choice and they stop panicking.

3. Keep the scene safe first: three rules of autosave

Most of the work in recovery goes into autosave. Save well, and recovery is "pick up where you left off"; save badly, and recovery is "do it all over again." Autosave has three rules, and all three are required.

First, save locally, without waiting for the network. Users log expenses in the subway, in an elevator, in a supermarket — the network comes and goes, so saving cannot depend on it. Every input goes to the phone's local storage first, and syncs to the server when it gets the chance. Local saving must be too fast to notice — finish one entry, lift your finger, and it is already on the phone. Second, save half-finished work, not only finished work. Many apps only save when the user taps "Save," "Submit," or "Done," so a crash midway loses everything half done. The right approach saves the half-done too: a half-written note, a half-filled form, half-selected photos are all "work in progress," and all of it gets saved. What the user should find on return is "everything you were halfway through is right here," not a clean new page. Third, make saved work recognizable. When they come back, the half-finished item should say so plainly: "This is the note you didn't finish," "This is the form you didn't submit." One tap continues it. Do not make users dig around guessing "where was I?"

Autosave also needs a retention limit: how long do drafts stay on the phone? The fictional number in this guide is 30 days. The number is fictional; the point is to have a clear limit and to tell the user. Thirty days or seven, decide it, write it in the product notes, warn the user before it expires — "This draft is about to expire, want to finish it?" — and only then clear it. Never silently delete something a user left unfinished. A user who comes back three months later looking for a half-written note and finds it gone will not think "expiry cleanup is reasonable." They will think "this app lost my stuff."

One more line not to cross: autosave should only keep "what the user is doing," not "what the user hasn't decided to do." A user opens a new page, writes nothing, and leaves — no need to keep an empty draft. A user types two letters in a search box and walks away — no need to keep a search record. Half-finished work is worth saving only when the user has already invested in it. The test is simple: more than one line typed, more than one photo picked, more than one field filled — then start autosaving.

4. Reopen where they left off: four things the recovery screen must do

With the work safe, the next question is whether the person can get back. When users reopen the app, the thing they most want to see is not the home page — it is the page they were on. Restoring the screen takes four things, and missing one sends the user hunting for their own way back.

First, return to the same page: halfway through logging expenses, come back to the expense page; reading the third article, come back to the third article; a pile of filters set, come back with the filters still set. Never dump everyone on the home page — the home page is where you start over, and a user after a crash least wants to start over. Second, return to the same position: the list scrolled to the same item, the article at the same paragraph, the form at the same field. Get the position wrong and the user has to scroll and search, and while searching they forget what they were doing. Third, say one sentence: a light note at the top of the page — "Welcome back — the entry you were halfway through has been restored." One sentence is enough: it tells the user "we know you crashed, your stuff is here, carry on." Fourth, do not keep asking: show the restore note once and let it go once dismissed. Popping up "You crashed last time, want to restore?" on every launch is a reminder on every launch that "this app crashes."

One more detail on restoring the screen: confirm the stuff is really there before drawing the page. Do not draw the page fast and load the data slowly to look quick — a user who sees an empty page thinks "it's lost," and even if the data appears two seconds later, the scare has already happened. The rule is "draw the page once the data is in hand": read the locally saved half-finished work first, confirm it is there, then draw the screen. Half a second slower is fine; an empty screen is what hurts. If Zhou Zhou had reopened the app to "You were on your second entry — greens for 12 is saved, carry on," she would never have thought of deleting it.

5. Crash reports need consent: don't quietly take the user's things

After a crash, what developers want most is the crash report — which line of code broke, how much memory was left, what step the user had reached. Without a report, fixing a crash is guesswork. But a report can carry the user's things: the entry being typed, the words being written, the content being viewed. Before taking a report, get the user's consent, and say clearly what you are asking for.

Consent has three rules. First, plain words: not "Send diagnostic data to improve the product experience," but "The app just crashed. Send us the error details so we can fix it? It doesn't include your ledger." Users agree when they understand; when they don't understand, the default is no. Second, take only what fixing the crash needs: the error stack, the device model, the system version, which page they were on — those are fine; the content being typed, the list being viewed, account details — those stay out. Write the list down before taking anything, and never sweep up something not on the list just because it is there. Third, one consent covers one crash: the user agreeing this time does not mean never asking again. Every crash is a new decision, and the user has the right to say yes this time and no next time.

One practice to avoid: forcing consent with "send it or you can't continue." Some apps show a crash dialog with only one button, "Send and continue" — refuse and you cannot get out. That holds "keep using the app" hostage in exchange for a crash report. Users who tap agree remember "this app forced me to hand things over," and next time it crashes, their first thought is not "help the developer fix a bug" but "here comes another forced handover." The right way is two buttons side by side: "Send report" and "No thanks, continue" — whichever they pick, they can keep using the app. The people who pick "Send report" are the ones who genuinely want to help.

6. When it keeps crashing: after three times, live differently

One crash, users forgive. The same thing crashing again and again, they do not. The usual shape of a repeat crash is: the user opens a certain page and it crashes, restarts, opens it again, crashes again — a loop. After two tries the user understands: it is not bad luck, it is that page. At that point the product should not keep letting them try. It should live differently.

The fictional number in this guide is: 3 crashes within 10 minutes triggers safe mode automatically. The number is fictional; the point is to have a clear trigger. Safe mode means: switch off the newest features, switch off animations and effects, keep only the core flow running. For a budgeting app, safe mode is "log expenses and view the ledger, everything else tucked away"; for a notes app, "write and list notes, sync and plugins paused." Safe mode is not making the product crippled; it is letting the user at least finish the thing that matters most. When safe mode starts, tell the user plainly: "This page just crashed 3 times, so we're using a simple mode to let you finish logging — we'll tell you once it's fixed."

Repeat crashes need two companion habits. First, do not make the user discover the pattern themselves: after two tries the user has learned "this page crashes" and will walk around it forever, which means the feature is dead. The product should spot it first: the same page appearing three times in crash reports should flag itself and get fixed, not wait for complaints. Second, say so once it is fixed: leave a light note in the app — "The crash you hit last time is fixed." The next time the user opens that page, they feel safe. Fix it and say nothing, and the user will remember "this page crashes" and avoid it for life.

7. Apology and compensation: what to say and do after a crash

The work is safe and the person is back. The last job is facing the user. Many teams say nothing after a crash, pretending it never happened — the user restarts, redoes the work, and the product stays silent. That is the worst approach: the user plainly lost something, and the product acts as if nothing happened. The user keeps score. An apology is not weakness; it is owning it.

An apology says three things. First, admit it: it crashed just now, and it was our fault. Second, report: your stuff is safe — the entry you were halfway through is still here. Third, state the plan: we have the report, we are fixing it, and we will tell you when it is done. Three sentences, in plain words — not "We sincerely apologize for the inconvenience and will keep improving the product experience," which nobody remembers after reading ten times. Say it once; apologize every time they open the app, and all the user remembers is "this app is always apologizing."

Should you compensate? It depends. For a free product, keeping the work safe and fixing the problem is the best compensation there is — do not compensate for the sake of it. For a paid product, when a feature the user pays for crashed and cost them real time, make the compensation concrete: extend the membership a few days, refund one month, offer one human support session — sized to match the loss. The thing to avoid with compensation is making people work for it: "a free month" that the user has to claim, and claiming needs a card, and the card needs watching ads — after all that effort to collect the compensation, no compensation would have been better. The rule is: no claiming, no applying, automatic — the user opens the app and sees "we've already made it up to you."

One more line: do not turn a crash into marketing. Some teams push a notification after a crash — "We crashed, but we're trying so hard!" with a self-mocking sticker. A user who is still angry will only get angrier — they lost time, and you turned it into a joke. For a month after a crash, do not joke about that crash anywhere. Save the humor for occasions that have nothing to do with it. In front of a user's loss, own it first, fix it, and hand their work back.

8. Pre-launch checklist

Go through this list item by item before shipping any feature where users have "work in progress." First, all three autosave rules are in place: save locally without waiting for the network; save half-finished work, not only things after the user taps "Save"; when they return, the half-finished item says so plainly and continues with one tap; drafts are kept 30 days (fictional number), with a warning before expiry and cleanup only after — never silently deleted. Second, reopening returns them to where they were: the same page and the same position; one light note at the top saying the work is restored; the note shown once; the page drawn only once the data is in hand, never an empty page first. Third, a freeze gives them something to hope for: plain words after 3 seconds of no response, and after 10 seconds the two choices "Wait a little longer" or "Restart the app — your content is saved" — never a silent spinner. Fourth, crash reports ask for consent: plain words, no user content included, only what fixing the crash needs, one consent per crash; "Send report" and "No thanks, continue" side by side, never holding continued use hostage. Fifth, repeat crashes have a safe mode: 3 crashes within 10 minutes (fictional number) switches to safe mode automatically, core flow only, and the user is told plainly; a page crashing three times gets flagged and fixed, and users are told when it is fixed. Sixth, the apology says three things: admit it, report what is safe, state the plan — in plain words, once; paid products compensate when owed, automatically, with nothing to claim; and for a month after a crash, no jokes about it.

And six pitfalls to repeat once more. First, do not stare only at the crash rate: the rate will never reach zero, and how good the recovery is decides whether users leave. Second, do not save only when the user taps "Save": a crash midway loses every half-finished thing, which is the same as not saving. Third, do not dump everyone on the home page: a user after a crash least wants to start over. Fourth, do not draw an empty page and load the data later: an empty page reads as "it's lost." Fifth, do not quietly take crash reports: ask in plain words, and take only what fixing the crash needs. Sixth, do not pretend nothing happened: admit it, report what is safe, state the plan — then get back to work.

Recovery funnel (fictional sample): 100 app crashes, 86 autosaves kept half-done work, 71 reopened on the same screen, 58 finished without redoing, 41 said they would keep using it

Back to Zhou Zhou. She still uses "Ledger Cat" — not because it never crashed again, but because last month it did crash again: she was logging expenses on the subway, halfway through an entry, when the screen went black. She reopened it and was back on the expense page in 3 seconds, with a small line at the top: "The entry you were halfway through has been restored." Greens for 12 and eggs for 18 were both there; she just had to add the pork ribs. The app also asked her: "It just crashed — send us the error details so we can fix it? It doesn't include your ledger. Is that okay?" She tapped yes. A crash is still a crash, but this time she lost nothing, redid nothing, and never panicked at a checkout. That is what crash recovery does: someday the app will crash in a user's hands, and in that moment the product's job is not to explain, apologize, or make the user start over — it is to hand the user's half-finished work back exactly as it was, so they can finish what they were doing as if nothing had happened.

Views 7Comments 0

Comments (0)

ME
0/1000
Loading comments...
Browse projectsPublish your project

Related articles

Real photo: a laptop, tablet, and phone on a wooden table showing the same green-leaf website, the phone view with navigation in one column, a potted plant nearby
Guide
Squashed on phones? Responsive layout and media queries, explained plainly

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.

Mobile AppsDesign ExperienceFrontend Engineering
Real photo: a young programmer debugging code at two monitors, the right screen full of red error text
Guide
Stop guessing at errors: try...catch and Error, explained plainly

A page that crashes on a bad JSON string, a null no one checked, an error thrown inside a callback that no try could catch. This guide follows MDN's try...catch, Error, and throw references: three kinds of errors, the three try shapes, finally's rules, nested tries and re-throwing, branching with instanceof, the Error family, cause, and the callback trap.

DebuggingFrontend EngineeringAI Coding
Real photo: a bank of light gray metal filing cabinets with one drawer pulled open, revealing rows of hanging file folders inside
Guide
A real database inside the browser: IndexedDB local storage, explained plainly

localStorage only stores strings and has no indexes. IndexedDB is a real database in the browser: structured data, far larger capacity, indexes, and transactions. Following MDN's Using IndexedDB, IDBDatabase, and IDBObjectStore: the five-step routine, opening, upgrades, keys, indexes, transactions, add versus put, get, cursors, ranges, and multi-tab upgrades.

Tool TipsData WorkflowsFrontend Engineering