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.
In-depth practical guides
Define what must roll back, retain a coherent version and verify recovery: a practical plan for files, data, languages, caches and user journeys.
Updated :

AI-generated illustration
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
Open each proposition to compare its diagnosis. More checks may still be needed.
No. It compares bytes with a reference; it tests neither configuration, journeys nor later writes.
Yes. Link version, environment, passing journeys and limits. Actual return to service remains a separate decision.
No. Legitimate later writes could be lost. Preservation or reconciliation must precede replacement.
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.
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.
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.
List writes between backup and incident. Preserve legitimate records before replacement and check compatibility. If reconciliation is unavailable, document possible loss before deciding.
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.
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
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.
| Item | Legitimate requests |
|---|---|
| In the morning backup | 300 |
| Received after the backup | 13 |
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 new version changed the schema, test reconciliation on a copy. Do not assume old code accepts every new record.
Keep versions, write inventory, protected backups and before/after ID checks.
Only when it covers the necessary elements. Data, media, indexes or dependencies may live separately; identify them before claiming the version is recoverable.
First identify which layer serves the wrong version. Verify a targeted action; cache mechanisms and commands depend on hosting.
It indicates HTTP response success, not correct content or task completion. Compare against expected results.
When the defect is understood, limited and repairable without making data worse. Compare duration, effects on writes and the ability to verify each option.
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
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.
| Reference | Value or form | What it identifies |
|---|---|---|
| 1 B | 8 bit | Under 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 MB | 1 000 000 B | Decimal prefixes use powers of ten: 1 MB is exactly 1,000,000 B. |
| 1 MiB | 1 048 576 B | The binary Mi prefix denotes a power of two: 1 MiB is exactly 1,048,576 B. |
| 1 GB / 1 GiB | 1 000 000 000 B / 1 073 741 824 B | One GB is 1,000,000,000 B and one GiB is 1,073,741,824 B. The unit name is necessary to interpret capacity. |
| t | 8 × 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. |
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.
t(s) = volume(B) × 8 / throughput(bit/s) 1 GB / 100 Mbit/s → 80 s 1 GiB / 100 Mbit/s → 85.89934592 s
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.
Documentation consulted on .
DOCUMENTED REFERENCE
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.
| Reference | Value or form | What it identifies |
|---|---|---|
| RPO | recoverable point | RPO 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. |
| Δdata | incident − recoverable point | The gap between the actual recoverable point and the incident is a window of potentially unrecovered data. It does not give a lost-record count. |
| RTO | system resource | RTO concerns the allowable unavailability of a system resource. Define the measurement boundaries and expected service level before the exercise. |
| MTD | mission / business process | MTD concerns the maximum tolerable interruption of the business process. A restored resource may still require validation or reprocessing before the process resumes. |
| Δprocess ≥ Δresource | model constraint | In this model the process cannot resume before the resource is restored. Meeting one objective does not offset missing another. |
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.
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.
Documentation consulted on .
DOCUMENTED REFERENCE
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.
| Reference | Value or form | What it identifies |
|---|---|---|
| snapshot | code + schema + data point | Record code version, data schema, media and recoverable point together. A file list without database state cannot establish a consistent set. |
| data | identifiers + expected writes | Read a predetermined sample and check identifiers and expected writes at the chosen point. Equal counts can conceal replacement or duplication. |
| integrity | bytes + trusted reference | Compare digests with a manifest of controlled provenance. A digest establishes byte equality with the reference, not the business correctness of that reference. |
| access | keys + permissions | Prepare an isolated environment and test necessary access, including keys. The archive can be readable while services or encrypted data remain inaccessible. |
| function | expected journey result | Check reading, search, languages, media and critical journeys against expected results. HTTP 200 does not establish that the correct version works. |
| dependencies | real / simulated / untested | Distinguish 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. |
| decision | timings + gaps + owner | Retain stage start/end times, results, differences, decision owner and follow-up actions. Late or partial observations must remain qualified as such. |
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.
Documentation consulted on .
DEEPER READING / PRACTICE
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 .
Identify files, data, configuration and access required. Test a restoration in an appropriate environment, and then check the pages, resources and essential interactions.
A present backup file does not prove its integrity or completeness. External dependencies or a lack of configuration can prevent proper recovery.
The restoration plan documented backed version, procedure, checks and test results. It specifies the non-covered elements and the information to be updated.