Getting it back is a procedure too
Backups are an easy thing to promise and an easy thing to leave vague. Here's what's actually captured, how far back you can go, what a restore costs in your own time, and what a tested restore means in practice.
Four shapes trouble takes
"Something's broken" isn't one problem — each shape below has its own path back, its own honest data-loss window, and its own answer to whether the site keeps serving while it happens.
A change broke it
Revert the merge — the same pipeline that shipped it redeploys the last known-good version.
- Data loss
- None. Nothing was deleted; the deploy just goes back to what was already running.
- While it happens
- Serving the whole time — a redeploy, not an outage.
Data was deleted or corrupted
Restore from the nightly backup, or roll a database with point-in-time recovery back to the moment before it happened.
- Data loss
- Depends on the tier — see the retention ladder below.
- While it happens
- Brief downtime while the restored copy is confirmed and promoted.
The machine or service failed
Rebuilt from the infrastructure definition, with the latest backup restored onto the replacement — because the stack is code, not something clicked together by hand.
- Data loss
- Up to the gap since the last backup — typically under 24 hours.
- While it happens
- Brief downtime while the replacement stands up.
You want a copy of something from last Tuesday
Ask through the same quote channel — pulling an old backup for a look is routine, not an escalation.
- Data loss
- None. This is a read, not a rollback.
- While it happens
- Nothing about the live system changes to answer this.
The manifest
Every item below is a real, standard file format — nothing that only opens with us, the same discipline as the portability pack. See Files for what actually lands in the "Uploaded & user files" row below.
| Item | How it's captured | What it gets you |
|---|---|---|
| Database | Nightly dump, plus point-in-time recovery on the tiers that carry it | Rolling back to last night, or to the moment before a bad write. |
| Uploaded & user files | Backed up alongside the database, same nightly schedule | One restore, not a database dump plus a media folder you hope you still have. |
| Application code | Full git history, not a snapshot | Every commit that ever touched it, recoverable to any prior state. |
| Infrastructure definition | Code, in the repo | The exact shape of the stack, rebuildable from scratch if the running instance is gone. |
| DNS zone | Standard zone file | Records restorable without waiting on a registrar support queue. |
| Environment & config values | Encrypted export | Everything the app reads at startup, restorable without guessing at a missing key. |
| Deploy pipeline definition | Code, in the repo | Whatever ships a merge today still ships it after a rebuild. |
How a restore actually goes
One procedure, whichever failure mode above brought you here.
That's the whole procedure added up — a typical estimate, not a measured average — and most of it is confirming what came back rather than doing the restore yourself.
- You~10 min
Say what's gone, and roughly when it was last right
Through the quote form — what happened, and the last time it looked correct.
- CustomHostedNothing
The right path gets picked
A revert, a backup restore, or a point-in-time rollback — whichever fits what actually happened.
- CustomHostedNothing
Restored into a throwaway copy first
The chosen backup or moment in time is pulled into a copy of the stack, not applied straight to the live one.
- You~10 min
Confirm it's the right copy
A look at what came back before it replaces anything live.
- CustomHostedNothing
The copy is promoted
The confirmed copy replaces the broken one, and traffic is already pointed at it.
- CustomLabsNothing
If the cause was a code bug, not just data
The fix ships as a briefed change through the same pipeline, once the data itself is back.
- You~5 min
Confirm it's really back
A quick check on your end closes it out.
The retention ladder
Retention and the data-loss window it implies, tier by tier — the same figures the rate card posts, not a separate set typed out here.
| Tier | Retention | Data-loss window |
|---|---|---|
| Every plan, by default | Daily backups · 7-day retention | Up to 24 hours — the gap since the last nightly backup. |
| Extended backup retention (30-day) | Daily backups kept for 30 days instead of 7. | Same 24-hour gap, further back in time to ask for. |
| DB Standard | 7-day PITR | Minutes, not hours — roll back to just before the write that broke it. |
| DB Plus | 30-day PITR | Minutes, not hours — roll back to just before the write that broke it. |
The drill
Taking a backup and never restoring it is a false sense of security. This is the procedure that converts "tested" from an adjective into something that happened.
- 1
Restore into a throwaway environment
A real backup, pulled into a copy of the stack that is never the live one.
- 2
Boot the app against it
Start the application on top of the restored data — a running check, not just a file check.
- 3
Walk the traffic paths that matter
Log in, load the pages that hit the database directly, confirm the data matches the moment it was taken from.
- 4
Write down what broke
If a step needed a manual fix or ran long, that goes in the record — a drill that always goes perfectly is not being run honestly.
- 5
Destroy the copy
The throwaway environment comes back down. Nothing about the drill ever touches the live system.
The honest limits
Said plainly, not buried — the same discipline as every other honesty band on this site.
Anything past the retention window
Once a backup ages out, it's gone. Ask before the window closes, not after.
A compliance archive
A backup is built to restore a broken system, not to satisfy a multi-year audit requirement — that's a separate, deliberate arrangement, not something a nightly backup happens to double as.
Data held in a third-party service
Anything living in a service we don't run — a payment processor, an email platform, an analytics tool — backs up on that service's own schedule, not ours.
A change you asked for and regret
That's a revert, not an incident — the first failure mode above, not this one.
One number is deliberately missing from this page: a stopwatch recovery-time figure. We haven't measured one across every stack we run, and an invented number is exactly the kind of claim this site refuses to print — what we publish instead is the procedure above, the retention window for your tier, and who to ask.
Recovery questions
The follow-ups that come up once losing something is a real possibility, not a hypothetical.
01How fast will my site be back?
We don't publish a stopwatch recovery-time figure, because we haven't measured one across every stack we run, and an invented number would be exactly the kind of claim this site refuses to print. What we publish instead: the procedure above, the retention window for your tier, and who to ask.
02How much data can I actually lose?
It depends on the tier. Every plan keeps daily backups · 7-day retention by default, so the most you can lose to a plain restore is the gap since the last nightly run. The PITR tiers cut that down to minutes — see the retention ladder above.
03What does a restore cost, on my side?
Under 25 minutes of your own time, spread across the steps above — mostly confirming what came back rather than doing anything yourself.
04Do you actually test the backups, or just take them?
Both. Taking a backup nightly and never restoring it is a false sense of security — the drill above runs against a throwaway copy, on a schedule, specifically to catch a backup that looks fine but wouldn't actually boot.
05What if the problem is a bug in my own code, not lost data?
That still isn't a restore — see the first failure mode above. Revert the merge and the same pipeline redeploys the last working version, no data touched at all.
06Can I just ask for an old copy without it being an emergency?
Yes — pulling a backup from a specific day for a look is routine, not an incident. Ask through the same channel as everything else.
What recovery connects to
- Security
Where "tested restores" first gets asserted, next to backups, patching, and TLS.
- Portability
The planned exit — leaving on purpose. This page is its unplanned sibling.
- The Loop
The revert path behind the first failure mode below: the same pipeline that ships a change ships it back.
- Environments
Where the revert-vs-restore boundary below is drawn from the other side: promotion, rollback, and what counts as a restore instead.
- Databases
The PITR ladder in full, plan by plan, alongside everything else a managed database includes.
- Patching
The snapshot this page describes is the first step of every patch window — see the rest of what a window does.
Something needs restoring?
Say what happened through the quote form — pulling an old backup for a look is routine, not an escalation.