In-depth practical guides

Prepare website recovery after an update

Define what must roll back, retain a coherent version and verify recovery: a practical plan for files, data, languages, caches and user journeys.

Updated :

Backup drive and verification notebook. Illustrative scene.

AI-generated illustration

Can service be restored without losing legitimate changes?

An archive is not yet a recovery procedure. It may contain code without data, one language without others, or files incompatible with the current state. Preparation means defining expected service, acceptable losses and evidence of consistency. These are planning examples, not incidents observed on this website.

  1. Describe a coherent version

    Associate code, content, search indexes, media and any writable data with a version. Distinguish replaced files from subsequent writes. Record external dependencies and execution prerequisites. Keep secrets in their existing management system rather than copying them into a public archive.

  2. Set recovery criteria

    Define priority tasks: reading a profile, searching, using a tool or submitting a form. Set a target duration and acceptable data loss for the context, without inventing a guarantee. Decide which defects require restoration and which permit a limited correction.

  3. Test isolated restoration

    Recreate the version in a separate environment with suitable test data. Check integrity and compatibility. Disable external actions there to avoid real sends or modifications. Measure the necessary steps: an available but untested copy does not demonstrate recoverability.

  4. Preserve subsequent writes

    Before rollback, identify received submissions, profile edits and other writes since the backup. Plan preservation or reconciliation when required. Do not replace an active database with an older copy without understanding lost data and schema dependencies.

  5. Handle caches and errors

    Check browser, server and intermediary caches separately. Restored HTML may still request CSS from another version. Inspect resource URLs and suitable headers. Consult authorized logs without displaying internal details or sensitive data in visitor-facing errors.

  6. Validate recovery

    Check HTTP responses, key pages, search, canonicals, languages and assets. Test an expected error without triggering a real action. Observe priority tasks after recovery and record limits. HTTP 200 alone proves neither correct content nor a functioning form.

  7. Compare new and already active visits

    Test the restored version in a new session and one that loaded the previous state. Record received resources and the cache serving them. This contrast can expose mixed versions hidden by a fresh browser. Define the check before an incident using test data and without indiscriminate cache purges.

Reading workshop

A recovery rehearsal with four separate proofs

The DEMO scenario describes an isolated exercise. This workshop restores no real website, account or service.

Fictional data and records for learning: none of these results comes from a live service query.

A readable archive is only the first check

The fictional dossier contains an archive and reference manifest. The team must decide whether returning to that version is prepared, without confusing files being present with usable service.

  1. Identify the copy

    Exercise evidence
    DEMO archive and hash matching the manifest
    What it establishes
    Checked bytes match the expected copy
    What remains to check
    The manifest itself needs known provenance.
  2. Rebuild in isolation

    Exercise evidence
    Code and content loaded with compatible configuration
    What it establishes
    The version can start in this test environment
    What remains to check
    Data, dependencies and schema must also match.
  3. Replay journeys

    Exercise evidence
    Reading, search and languages checked with fictional data
    What it establishes
    These tasks pass within the tested scope
    What remains to check
    External sends remain disabled; real delivery is not proved.
  4. Decide on rollback

    Exercise evidence
    Criteria reviewed and later writes identified
    What it establishes
    A documented decision can be prepared
    What remains to check
    Do not overwrite new data; identify gaps and the decision owner.

Which conclusion correctly describes this exercise?

Open each proposition to compare its diagnosis. More checks may still be needed.

The hash is enough: service is restored

No. It compares bytes with a reference; it tests neither configuration, journeys nor later writes.

The rehearsal prepares a decision limited to its evidence

Yes. Link version, environment, passing journeys and limits. Actual return to service remains a separate decision.

Restore all old data to exactly match the backup

No. Legitimate later writes could be lost. Preservation or reconciliation must precede replacement.

Fictional rehearsal record

Version: DEMO archive, identified manifest
Integrity: matches the exercise reference
Environment: isolated, external sends disabled
Journeys: reading, search and languages checked
Reservation: preserve later writes
Decision: rollback not executed; owner to designate

This filled example is not evidence of a test performed on this website. Each statement would need an observation in a real exercise.

Documentation of the rules, separate from fictional examples

Compare other situations and exercises

HTML returns but styling stays old

Compare document version, CSS URL and the actual file received. Inspect the relevant cache before repeated purges. Restore a coherent set and check the photographs and scripts used by that version.

The index lists removed pages

Code and content have returned, but search uses another version's index. Rebuild it from the retained corpus and check queries, destinations and languages. Restoring files does not necessarily restore derived data.

New submissions follow the backup

List writes between backup and incident. Preserve legitimate records before replacement and check compatibility. If reconciliation is unavailable, document possible loss before deciding.

The new session passes but the old one retains an incompatible script

Fictional case: a reader keeps a cached script while HTML has been restored. The page opens but a local action fails. Compare script URL and content, then restore a compatible set. Do not declare recovery based only on a session that never loaded the previous version.

The backup restores five of six languages

Illustrative example: French works but a translation file is absent from the archive. Test every declared language and error state, then inspect the backup manifest. Silent fallback to the main language is not full restoration; keep the gap in the recovery decision.

Worked exercise

Restore code without losing new submissions

Fictional example: the values and documents teach the method and do not describe a real organisation.

The incident affects code only. Current data remain readable; verify compatibility with the restored code.

If the table exceeds the screen, scroll horizontally; arrow keys work when the region is focused.

Starting information
ItemLegitimate requests
In the morning backup300
Received after the backup13

Your checks

  1. Identify code, configuration and written data separately.
  2. Preserve a copy of the 13 requests before any operation.
  3. Check old-code compatibility with current data.
Read the answer

Answer and decision

Restoring the entire backup would return to 300 requests and omit the 13 new ones. Prepare a code rollback with current data if compatibility is verified. The expected result retains 313 distinct requests; an HTML page returning does not validate continuity.

If the case changes

If the new version changed the schema, test reconciliation on a copy. Do not assume old code accepts every new record.

Record to retain

Keep versions, write inventory, protected backups and before/after ID checks.

Record to retain

  • Reference version: files, content, indexes and associated dependencies.
  • Recovery scope, priority tasks and decision criteria.
  • Isolated trial result, observed duration and subsequent writes to preserve.
  • Recovery checks: HTTP status, content, languages, assets and remaining limits.
  • New and existing sessions, received resources and restored-language coverage.

Official references

Related protocols

Checks before reaching a conclusion

  • Does the chosen backup combine compatible files and data rather than two copies captured at different times?
  • Has recovery been tried on representative pages, languages, searches and data before being considered available?
  • Do recovery criteria specify who decides, which version to restore and which checks permit service to resume?
  • Does recovery also work for a reader who already loaded the preceding version?

Frequently asked questions

Is a file backup sufficient?

Only when it covers the necessary elements. Data, media, indexes or dependencies may live separately; identify them before claiming the version is recoverable.

Should every cache be cleared?

First identify which layer serves the wrong version. Verify a targeted action; cache mechanisms and commands depend on hosting.

Does HTTP 200 mean recovery is complete?

It indicates HTTP response success, not correct content or task completion. Compare against expected results.

When is a fix preferable to rollback?

When the defect is understood, limited and repairable without making data worse. Compare duration, effects on writes and the ability to verify each option.

How can one tell if a backup is really useful?

Checking that it allows to reconstruct the necessary elements and pathways. The test result and the known limits give evidence of a stronger recovery capacity than its sole presence.

DOCUMENTED REFERENCE

Volume and throughput: state the units before estimating a transfer

The same number describes different volumes in GB and GiB. To prepare migration or recovery, first convert the size to bytes and throughput to bits per second. The calculator then gives an arithmetic duration at constant throughput, not a network measurement.

volume × unit → Brate × unit → bit/st = 8 × B / (bit/s)
Volume and throughput: state the units before estimating a transfer
ReferenceValue or formWhat it identifies
1 B8 bitUnder the convention used here, one byte B is eight bits. A rate in MB/s is therefore not the same numerical rate in Mbit/s.
1 MB1 000 000 BDecimal prefixes use powers of ten: 1 MB is exactly 1,000,000 B.
1 MiB1 048 576 BThe binary Mi prefix denotes a power of two: 1 MiB is exactly 1,048,576 B.
1 GB / 1 GiB1 000 000 000 B / 1 073 741 824 BOne GB is 1,000,000,000 B and one GiB is 1,073,741,824 B. The unit name is necessary to interpret capacity.
t8 × volume(B) / débit(bit/s)At a constant 100 Mbit/s entirely available to the data, serialising 1 GB takes 80 seconds; 1 GiB takes 85.89934592 seconds. These are calculated examples.

Estimate ideal transfer time

Decimal volume from 0 to 1,000,000; positive throughput up to 1,000,000. At most six decimal places, point or comma, no grouping or exponent.

Constant-throughput calculation without network access. Results rounded to six decimals.

Volume · bytes B
1000000000.000000
Throughput · bit/s
100000000.000000
Ideal time · seconds
80.000000
Ideal time · minutes
1.333333
t(s) = volume(B) × 8 / throughput(bit/s)
1 GB / 100 Mbit/s → 80 s
1 GiB / 100 Mbit/s → 85.89934592 s

Implication for the record

The formula excludes headers, retries, shared throughput, latency, encryption, compression and read/write speeds. Use the volume actually transferred. This ideal duration is neither a recovery-time commitment nor a bandwidth test.

Primary documentation

Documentation consulted on .

DOCUMENTED REFERENCE

Recovery: connect RPO, RTO and business-process interruption

An exercise may recover recent files yet restore service too late. It may also restore service quickly using data that is too old. This reader compares three distinct measurements against three user-entered objectives; its numbers are teaching examples, not commitments by this site.

Recovery: connect RPO, RTO and business-process interruption
ReferenceValue or formWhat it identifies
RPOrecoverable pointRPO identifies the point in time to which data must be recoverable. To compare it with an incident, this model expresses the allowed look-back in minutes.
Δdataincident − recoverable pointThe gap between the actual recoverable point and the incident is a window of potentially unrecovered data. It does not give a lost-record count.
RTOsystem resourceRTO concerns the allowable unavailability of a system resource. Define the measurement boundaries and expected service level before the exercise.
MTDmission / business processMTD concerns the maximum tolerable interruption of the business process. A restored resource may still require validation or reprocessing before the process resumes.
Δprocess ≥ Δresourcemodel constraintIn this model the process cannot resume before the resource is restored. Meeting one objective does not offset missing another.

Compare an exercise with three objectives

Six integers from 0 to 1,000,000 minutes. In this model the process cannot resume before the resource.

Objectives compared separately; no recovery test is executed.

ΔdataΔITΔprocess
Bars show measurements; vertical marks show entered objectives.
Data · observed / allowed look-back
45 / 30 · Limit exceeded
Resource · unavailability / RTO
90 / 60 · Limit exceeded
Process · interruption / MTD
120 / 180 · Within entered limit
Data / resource / process exceedance · min
15 / 30 / 0

Implication for the record

Definitions follow NIST SP 800-34 revision 1, updated 11 November 2010. The organization must define scope, units and measurement start points. A scheduled backup interval does not prove actual RPO: a copy may be inconsistent or unusable. Arithmetic comparison establishes neither data integrity nor successful recovery.

Primary documentation

Documentation consulted on .

DOCUMENTED REFERENCE

Recovery exercise: connect each conclusion to evidence

A successful copy log, a matching digest and a usable application answer different questions. This table adapts the NIST guide’s data and functionality validation stages to a multilingual website. It describes evidence to produce during an exercise; it does not claim those tests were performed on your hosting.

snapshotdata + functionsdecision + gaps
Recovery exercise: connect each conclusion to evidence
ReferenceValue or formWhat it identifies
snapshotcode + schema + data pointRecord code version, data schema, media and recoverable point together. A file list without database state cannot establish a consistent set.
dataidentifiers + expected writesRead a predetermined sample and check identifiers and expected writes at the chosen point. Equal counts can conceal replacement or duplication.
integritybytes + trusted referenceCompare digests with a manifest of controlled provenance. A digest establishes byte equality with the reference, not the business correctness of that reference.
accesskeys + permissionsPrepare an isolated environment and test necessary access, including keys. The archive can be readable while services or encrypted data remain inaccessible.
functionexpected journey resultCheck reading, search, languages, media and critical journeys against expected results. HTTP 200 does not establish that the correct version works.
dependenciesreal / simulated / untestedDistinguish available, simulated and untested dependencies: third-party APIs, scheduled tasks, queues or messaging. A journey using a simulated service does not validate the real service.
decisiontimings + gaps + ownerRetain stage start/end times, results, differences, decision owner and follow-up actions. Late or partial observations must remain qualified as such.

Implication for the record

Adapt criteria to the relevant data and service without publishing secrets or backups. An isolated-environment exercise alone does not establish production timings or permissions. State what was demonstrated, what remains unverified and the conditions for another exercise.

Primary documentation

Documentation consulted on .

DEEPER READING / PRACTICE

Verify that a backup can be restored

Files are saved, but no one has verified their ability to reconstruct the site. The preparation of a restoration must include the dependencies and the steps necessary for a recovery.

Updated on .

Priority checks

Identify files, data, configuration and access required. Test a restoration in an appropriate environment, and then check the pages, resources and essential interactions.

Interpretation pitfalls

A present backup file does not prove its integrity or completeness. External dependencies or a lack of configuration can prevent proper recovery.

Working record to retain

The restoration plan documented backed version, procedure, checks and test results. It specifies the non-covered elements and the information to be updated.