The three corrective actions the previous lesson closed on — immutable backups in a separate account, a quarterly restore test and a deletion alert — are not incident response: they are another discipline. The response plan tells you how to act when the diaries of 40 clinics are at a standstill, but not how long they can be at a standstill before the business cannot take it, nor how much data you can afford to lose, nor how Rubén and the clinics carry on serving people while the system is down, nor how long a restore that nobody has ever timed really takes. This lesson answers those four questions and closes the module with the artefact that in 02-06 would have changed the outcome more than any other: a verified backup.

Contents

  1. Business continuity and disaster recovery: two different plans
  2. The business impact analysis (BIA)
  3. RTO and RPO: what they are, how they are set and what they cost
  4. Backup strategies
  5. The restore test: the heart of the lesson
  6. The ransomware scenario, which breaks the classic plans
  7. High availability is not a backup
  8. The written plan: DRP and emergency procedures
  9. Testing the plan, and cadence
  10. Metrics and continual improvement

  1. Business continuity and disaster recovery: two different plans

Business Continuity Plan (BCP) Disaster Recovery Plan (DRP)
Objective That the business keeps running That the technology works again
Scope Processes, people, suppliers, premises Systems, data, networks, infrastructure
Question How do we keep serving the clinics with no system? How do we get the platform back into production?
Owner Management (Marta) Systems (Lucía)
Nimbus example Rubén records appointments on a spreadsheet and the clinics work on paper following an agreed procedure Restoring PostgreSQL and the attachments bucket from the immutable backup
If it is missing Revenue stops even once the technology comes back The disruption drags on indefinitely

They are complementary and not interchangeable. An excellent DRP with no BCP means that during the 12 hours of recovery the clinics can do absolutely nothing and lose their patients; an excellent BCP with no DRP means you can cope by hand for a few days, but nobody knows when the system will come back or whether the data still exists.

And a point of vocabulary: in this context "disaster" does not mean earthquake. For an SME like Nimbus the realistic disasters are, in order of likelihood: ransomware, a mass accidental deletion, a prolonged outage at the cloud provider, a migration error that corrupts data and, a long way behind, a fire at the office. The plan is written against the first ones, not the last.


  1. The business impact analysis (BIA)

The BIA (Business Impact Analysis) is the mandatory starting point, and it answers a single question per process: if this stops, how much does it hurt and from when? Without a BIA, recovery objectives are set by intuition or by what the technology already does, which is exactly the wrong way round.

You identify business processes, not systems. The system is the means; the process is what the customer pays for.

Business process Systems it depends on MTPD Impact at 4 h Impact at 24 h Impact at 72 h
Viewing and creating bookings (end customers and clinics) A-04 API, A-01 DB, A-07 SPA/app 4 h 40 clinics working blind; complaints Lost appointments; patients who do not turn up; first cancellations announced Serious reputational harm; terminations
Viewing the history and the attachments A-01, A-02 bucket 24 h Inconvenience; people work from printouts Clinical decisions with no background The same as above
Invoicing and taking payment A-01, A-12 gateway 72 h None Delayed collection A cash flow problem if it builds up
Handling support Ticketing tool, e-mail 8 h Customers with no reply in the middle of a crisis A perception of abandonment Amplifies everything else
Paying payroll and suppliers Office suite, banking, accounting firm 5 days None None None until month end

The MTPD (Maximum Tolerable Period of Disruption) is the longest the business can bear that process being interrupted before suffering harm that can no longer be repaired. Three rules for setting it properly:

  • The business sets it, not technology. Marta and Rubén know at what point a clinic starts ringing its patients to reschedule; Lucía does not.
  • Not everything is critical. If every process in your BIA has an MTPD of 1 hour, you have not done a BIA: you have made a wish list, and the result will be that nothing gets prioritised.
  • Impact is not linear. Look at the table: two hours of outage are an inconvenience and twenty-four are a crisis. That is why the BIA is measured in bands, not with a single number.

One observation about the Nimbus case worth internalising: the most critical process (bookings, MTPD of 4 h) is not the one that handles the most data, and the one that handles the most sensitive data (history and attachments) tolerates considerably more disruption. Confidentiality and availability have different priorities, which is why the risk register in 04-01 gave the outage a higher ALE than the leak despite it being far less serious per event.


  1. RTO and RPO: what they are, how they are set and what they cost

flowchart LR
    U["Last valid\nbackup"] -->|"RPO = data that is lost\n(BACKWARDS from the disaster)"| D["DISASTER\nt = 0"]
    D -->|"RTO = time until you are back\n(FORWARDS)"| R["Service restored"]
    R -->|"must be less than"| M["MTPD from the BIA\n(the limit the business sets)"]
  • RPO (Recovery Point Objective): how much data you can afford to lose, measured in time. An RPO of 1 hour means that, in the worst case, you lose the last hour's work. It is determined by the backup frequency.
  • RTO (Recovery Time Objective): how long you can take to come back. It is determined by the architecture and the procedure, and it must always be less than the MTPD.
Target RTO / RPO Technical strategy Relative cost
RTO 24-72 h · RPO 24 h Daily backup to cold storage; manual restore × 1
RTO 4-12 h · RPO 1-4 h Frequent backups + snapshots + automated, tested restore × 1.5
RTO 1-4 h · RPO 5-15 min Asynchronous replica to another zone; manual promotion of the replica × 2
RTO < 15 min · RPO ≈ 0 Synchronous multi-zone replica with automatic failover × 3-4
RTO < 1 min · RPO 0 Multi-region active-active × 5 or more

The difference between asynchronous and synchronous replication deserves a sentence: with asynchronous replication the write is acknowledged to the client before it reaches the copy, so it is fast and may lose the last few seconds; with synchronous replication nothing is acknowledged until both copies have it, which guarantees an RPO of zero at the cost of latency on every write and of a problem in the secondary zone degrading the primary.

Nimbus's objectives, derived from the BIA and not from wishful thinking:

System RTO RPO Strategy Rationale
API + database (A-04, A-01) 4 h 15 min Continuous transaction log shipping + daily full backup + snapshots The MTPD for bookings is 4 h; losing 15 min of appointments is recoverable by phoning
Attachments bucket (A-02) 12 h 24 h Versioning + replication to a secondary region Greater tolerance; attachments do not block the diary
Repository and CI (A-06) 24 h 24 h Backup of the repository and the configuration A local copy exists on every laptop
Identity and e-mail (A-13) 8 h 24 h Depends on the SaaS provider + weekly export With no e-mail, support degrades
Public website 24 h 7 days Rebuild from the repository Static

And the rule that avoids the circular conversation: RTO and RPO are derived from the MTPD in the BIA, and only then do you check whether the budget allows them. If it does not, you do not change the number on the sheet: you document the gap as an accepted risk in the 04-01 register, with a signature. An RTO committed to a customer and not achievable is, as well as a lie, a breach of contract.


  1. Backup strategies

Type What it copies Advantage Drawback
Full Everything, every time Simple, fast restore: a single set Takes a lot of space and time
Incremental What has changed since the last backup of any type The fastest and the smallest Restoring requires the full backup plus the whole chain: if one link is missing, the rest is lost
Differential What has changed since the last full backup Restoring needs only two sets It grows every day until the next full backup

A typical and sensible scheme for Nimbus: a weekly full backup, a daily incremental and continuous shipping of the PostgreSQL transaction log — the last of these is what makes a 15-minute RPO possible, because it enables point-in-time recovery.

4.1 The 3-2-1-1-0 rule, digit by digit

It already appeared in 02-04; here it is developed, because each digit answers a different failure:

Digit Means Failure it neutralises At Nimbus
3 Three copies of the data (the original and two more) One copy being corrupt or incomplete Production + a copy in the cloud + a copy in a separate account
2 On two different media or technologies A systemic failure of the medium or the service Object storage + cold storage of a different kind
1 One copy off-site A disaster affecting an entire site or region Secondary region
1 One immutable or offline copy The attacker with administration credentials Bucket with locked retention in a separate account
0 Zero errors on verification Believing you have a backup when you do not Quarterly restore test

The last two digits are what separate this rule from the classic 3-2-1, and they are exactly the ones Nimbus was missing in 02-06. The fourth digit — immutability — is what prevents the deletion at 02:10 on day 20; the fifth — verification — is what would have revealed, weeks earlier, that the only alternative copy was an external disk five weeks old that nobody had tested.

There is one nuance about immutability that decides its effectiveness: it must be in an account whose credentials production does not know, and with retention locked in such a way that not even the administrator can shorten it during the period set. If the same set of credentials that manages production can turn off the retention, immutability is a label, not a control.

4.2 Retention, encryption and what to back up besides the data

Retention and versioning. Nimbus keeps: 7 daily copies, 4 weekly, 12 monthly and 1 annual. Long retention is not a whim: silent corruption or a logical deletion can be discovered weeks later, and with only seven days of retention the problem has already been replicated to every copy.

Encrypting the backup, with the key outside the environment (03-07). Backups contain the same data as production and travel to less closely watched places, so they go encrypted. And the key cannot be where the encrypted thing is: if the backup key lives in the same secrets manager the attacker already controls, encryption contributes nothing against double extortion. Separate custody, with a tested key recovery procedure — losing the backup key is losing the backup.

What is backed up besides the data, which almost nobody includes: the infrastructure configuration (ideally as code, versioned in the repository), the definition of the cloud resources, the secrets — encrypted and held separately — the certificates, the identity provider configuration and the recovery documentation itself. Restoring a database without being able to rebuild the infrastructure that serves it stretches the RTO by days.

And what a backup does NOT cover. This is the part that produces surprises: replicated logical deletion — if you delete a row and the copy synchronises, the copy deletes it too; propagated corruption, when an application error has spent weeks writing incorrect data that every copy faithfully contains; data that lives only in a SaaS that nobody exports; and schema changes, because a six-month-old backup may not be restorable into the current application without a migration process.


  1. The restore test: the heart of the lesson

An unverified backup is not a backup: it is a hope. That sentence sums up the entire module, and in the 02-06 case it was literal: a backup existed and it was no good. The three things you only discover by genuinely restoring are that the file is intact and readable, that the procedure works with the documentation that is actually written down, and how long it really takes — which is always longer than the estimate.

Type of test What it checks Duration Frequency at Nimbus
Automated verification That the backup exists, is a reasonable size and its hash matches Minutes Daily, automated
Partial restore That a specific table or file can be recovered 30 min Monthly
Full restore to an isolated environment Full integrity + real elapsed time measured against the RTO 2-4 h Quarterly
Full drill with an outage The whole DRP, including failover and the BCP Half a day Annual
#!/usr/bin/env bash
# restore-test.sh - Quarterly restore of the Nimbus database to an ISOLATED
# environment plus an integrity check. Never run against production or
# pre-production: an ephemeral environment is stood up for this.
set -euo pipefail

DATE_UTC="$(date -u +%Y%m%d)"
HOST_PROD="${HOST_PROD:-db-prod.interno}"   # only used to compare counts
BACKUP="s3://nimbus-backups-inmutable/postgres/nimbus-${DATE_UTC}.dump"
DB="nimbus_restore_test"
REPORT="restore-report-${DATE_UTC}.yaml"
T0=$(date +%s)                       # stopwatch: we measure the REAL RTO

# 1. Download the backup and VERIFY ITS HASH before using it. If the hash does
#    not match, the backup is corrupt and the test has already found a failure.
aws s3 cp "${BACKUP}"        "/tmp/backup.dump"
aws s3 cp "${BACKUP}.sha256" "/tmp/backup.dump.sha256"
( cd /tmp && sha256sum -c backup.dump.sha256 )

# 2. Restore into a NEW, empty database in the isolated environment.
#    --exit-on-error makes a failure stop the test instead of leaving a
#    half-finished restore that looks correct.
createdb "${DB}"
pg_restore --dbname="${DB}" --jobs=4 --no-owner --exit-on-error /tmp/backup.dump

T1=$(date +%s)
MINUTES=$(( (T1 - T0) / 60 ))

# 3. INTEGRITY CHECK. Restoring without errors is not enough: you have to check
#    that the data is complete and coherent.
APPTS=$(psql  -tAc "SELECT count(*) FROM appointments"        "${DB}")
CUST=$(psql   -tAc "SELECT count(*) FROM customers"           "${DB}")
LATEST=$(psql -tAc "SELECT max(created_at) FROM appointments" "${DB}")
ORPHANS=$(psql -tAc "SELECT count(*) FROM appointments a
                     LEFT JOIN customers t ON t.id = a.tenant_id
                     WHERE t.id IS NULL"                      "${DB}")

# 4. Comparison against production: a restore with half the rows is a failed
#    restore even if pg_restore returns 0.
APPTS_PROD=$(psql -tAc "SELECT count(*) FROM appointments" -h "${HOST_PROD}" nimbus)
DEVIATION=$(( (APPTS_PROD - APPTS) * 100 / (APPTS_PROD > 0 ? APPTS_PROD : 1) ))

# 5. Success criteria, evaluated explicitly.
OK=true
[[ "${ORPHANS}"   -eq 0 ]]                || { OK=false; echo "FAIL: orphan rows"; }
[[ "${DEVIATION}" -le 1 ]]                || { OK=false; echo "FAIL: missing rows"; }
[[ "${MINUTES}"   -le 240 ]]              || { OK=false; echo "FAIL: RTO exceeded"; }

# 6. Report with the result. With no report, the test did not happen.
cat > "${REPORT}" <<EOF
test: quarterly_restore
date: ${DATE_UTC}
source_backup: "${BACKUP}"
hash_verified: true
duration_minutes: ${MINUTES}      # REAL RTO measured
rto_target_minutes: 240
rpo_actual: "last appointment restored: ${LATEST}"
rows: {appointments: ${APPTS}, customers: ${CUST}, orphans: ${ORPHANS}}
deviation_vs_production_pct: ${DEVIATION}
result: $( [[ "${OK}" == true ]] && echo PASS || echo FAIL )
executed_by: "${USER}"
findings:
  - "The documented procedure omitted restoring the extensions"
  - "The 55 min include 12 of download: with the DB at twice the size the RTO
     would be borderline -> review before the next quarter"
actions: ["Update runbook RB-05", "Assess a parallelised restore"]
next_test: "$(date -u -d '+3 months' +%Y-%m-%d)"
EOF

# 7. Destroy the test environment: it contains real patient data.
dropdb "${DB}"
echo "Test completed in ${MINUTES} min. Report: ${REPORT}"

Five decisions in the script that are matters of method. It is timed, because the most valuable output of the test is not "it worked" but "it took 55 minutes" compared with the committed RTO. The hash is verified before restoring, so you do not discover the corruption halfway through. The row count is compared against production, because pg_restore can finish successfully having restored a truncated backup. Referential coherence is checked with the orphan rows query, which catches a partial restore that the overall figures would hide. And the environment is destroyed at the end, because it contains real patient data and a forgotten test environment is exactly the A-22 with a "to be reviewed" classification from the 01-04 inventory.

The report's findings field is what justifies the whole exercise: the test must produce findings. A restore test that comes out perfect first time almost always means the easy thing was tested.


  1. The ransomware scenario, which breaks the classic plans

Traditional recovery plans were designed against technical failure: a disk that breaks, a data centre that floods. Ransomware with double extortion breaks four assumptions of that model:

Classic assumption Why it fails with ransomware
"The backups are safe from the incident" The attacker has administration credentials and the backups reachable from the network are encrypted or deleted (day 20, 02:10 in 02-06)
"We restore and we are back" You have to rebuild the infrastructure, not just restore data: you cannot put the backup back into a compromised environment
"The RTO is the time it takes to restore" The real RTO includes investigating the scope, eradicating, rebuilding from scratch and validating. It multiplies
"Recovering solves the problem" The backup restores availability, not confidentiality: the exfiltrated data is still out there

Hence the four specific requirements against ransomware. Real immutability, with locked retention nobody can shorten. Isolation of the backup credentials: the account that writes the backups must not be able to delete them, and the one that reads them to restore must be a different one and out of production's reach. An offline or logically isolated copy as a last resort. And an RTO calculated for the full-rebuild scenario, not for restoring a file: if Nimbus promises 4 hours and its ransomware scenario requires 3 days, it has a commitment it cannot meet and it needs to know that before signing it.

Validation note. The decision on paying a ransom, the notification obligations arising from exfiltration and the insurance cover conditions are legal and contractual questions, not technical ones. They are taken up with legal advisers, with the compliance lead and with the insurer, whose policy usually imposes specific procedures (04-01, 04-05).


  1. High availability is not a backup

High availability (HA) Backup
Protects against Failure of a component or a zone Loss, corruption or encryption of the data
Mechanism Redundancy and automatic failover An independent copy in time
Faced with a mass DELETE It replicates it faithfully in milliseconds It lets you go back to the previous instant
Faced with ransomware It encrypts the replica too It lets you restore if it is immutable
Cost High and permanent Low and proportionate to the volume

The decisive row is the third. A replica is not a backup, because it replicates errors with the same diligence with which it replicates correct actions. Confusing the two is one of the most expensive and most frequent mistakes: "we have high availability" does not answer "and what if somebody deletes the appointments table?".

As well as redundancy, the BCP relies on graceful degradation: designing the system so that, on a partial failure, it keeps offering the essentials. At Nimbus that means that if the attachments bucket does not respond, the diary must carry on working in appointment read-only mode instead of returning a general error. Every degree of degradation the system can sustain reduces the per-hour impact in the BIA, and it is usually cheaper than moving up a rung on the RTO table.


  1. The written plan: DRP and emergency procedures

8.1 Recovery order by dependencies

Restoring in the wrong order stretches the RTO and produces confusing errors. The order derives from the dependency map in the 01-04 inventory:

flowchart TB
    A["1. Cloud account and network\nVPC, subnets, security groups,\nIAM roles (rebuilt from IaC)"]
    A --> B["2. Secrets manager and identity\nWithout secrets nothing starts"]
    B --> C["3. Database A-01\nRestore dump + transaction\nlog up to the chosen point"]
    C --> D["4. Object storage A-02\nAttachments from the versioned copy"]
    D --> E["5. API A-04\nDeployment from a SIGNED\nand verified image (03-07)"]
    E --> F["6. SPA and mobile app A-07\nDNS pointing at the new environment"]
    F --> G["7. Integrations\nGateway, transactional e-mail,\nwebhooks: re-enable and verify"]
    G --> H["8. VALIDATION\nFunctional tests, data\nreconciliation and customer communication"]

Two warnings about the diagram. Step 7 is deliberately left until last: re-enabling the integrations before validating can fire off hundreds of e-mails or duplicate charges with restored data. And step 8 is not optional: reconciliation — checking which appointments were created between the RPO and the disaster and are missing — is the work that turns a technical restore into a business recovery.

8.2 Manual emergency procedures (the BCP)

While the RTO runs, the business has to carry on. This is the part of the plan that is not technical and the part customers are most grateful for:

Process Manual procedure Preparation required
Bookings Each clinic works from its printed diary for the day; new appointments are noted on a template Nimbus sends by e-mail Automatic daily export of the next day's diary, sent to each clinic: if the system goes down, they already have it
Support Rubén replies from an alternative e-mail account with a status message and a phone number Account and template prepared out of band (04-05)
Status communication A status page independent of Nimbus's infrastructure Hosted with another provider; tested
Re-entering data The templates filled in by the clinics are loaded after the restore, with reconciliation Format defined and load script tested

The first row contains the most profitable idea in this lesson: an automatic daily export that each clinic already has in its inbox turns an operational catastrophe into an inconvenience, costs next to nothing and works even if the whole of Nimbus has vanished.

8.3 DRP template

# Disaster Recovery Plan — [Organisation]   v_._   Approved: ____

## 1. Scope and assumptions
Which systems it covers and which scenarios it contemplates (ransomware, loss of
a region, data corruption, mass human error). What is out of scope.

## 2. Roles and contacts
Coordinator and deputy · technical lead · communication · cloud provider ·
forensic retainer. Personal phone numbers. **Printed and out-of-band copy.**

## 3. Activation criteria
Who can declare the disaster and against what objective criteria
(e.g. "estimated unavailability greater than the MTPD of the critical process").

## 4. Objectives per system
RTO / RPO table per system, with the strategy that underpins them.

## 5. Recovery procedures
Start-up order by dependencies + one runbook per system, with the exact commands
and the emergency credentials required (a reference, not the value).

## 6. Manual emergency procedures (BCP)
How the business keeps operating while the recovery runs.

## 7. Validation and reconciliation
Functional tests, integrity verification and reconciliation of the data falling
between the RPO and the moment of the disaster.

## 8. Conditions for the return to normal operations
Criteria for declaring the disaster over: service stable for N hours, data
reconciled, enhanced monitoring active, final communication sent.

## 9. Test log
Date, type, real RTO measured, result, findings and actions.

## 10. Version history and next review date

  1. Testing the plan, and cadence

Type of test What it involves Cost Value Cadence
Document review Read the plan and check that the systems, people and phone numbers still exist Very low Medium: catches obsolescence Quarterly
Tabletop exercise Talk through the scenario without touching systems (04-05) Low High: catches decision gaps Every six months
Partial drill Genuinely restore one system to an isolated environment Medium Very high: measures the real RTO Quarterly
Full drill Complete recovery with a planned outage and the BCP activated High Maximum: it is the only total test Annual

The quarterly partial drill has the best cost-to-value ratio and is the one Nimbus cannot skip. The annual full one is best done in a planned window and with customers warned: a drill that goes wrong in an agreed slot is learning; the same failure in a real disaster is a crisis.

And one rule that closes the module's cycle: every test produces findings, and every finding becomes an action with an owner and a date that goes into the 04-01 risk register and, where relevant, into the 04-03 control catalogue. Without that, testing is a ceremony.


  1. Metrics and continual improvement

Metric What it reveals Target at Nimbus
Real RTO of the last test against the committed one Whether the promise is true ≤ 240 min
Age of the last successful test (KRI from 04-03) Control drift ≤ 90 days
Backup success rate (last 30 days) Health of the daily process ≥ 99 %
Coverage: systems with a verified backup / critical systems What nobody is backing up 100 %
Age of the most recent verified backup The effective RPO, not the theoretical one ≤ target RPO
Open findings from the last test Whether the learning gets closed 0 after 90 days

The metric that most surprises people the first time they measure it is coverage: there is almost always some critical system — the identity provider configuration, the ticketing tool, the data in a SaaS — that nobody was backing up because everyone assumed the provider did it. It is the shared responsibility from 04-04 showing up in practice.


Common Mistakes and Tips

  • Having backups and never having restored them. It is the mistake of the whole module, and in 02-06 it was literal. Tip: the quarterly test in the calendar, with a report and findings; with no report, the test did not happen.
  • Setting the RTO by what the technology already does. You get a comfortable, false number. Tip: the BIA and the MTPD first, the technology afterwards, and if it does not reach, document it as an accepted risk with a signature.
  • Backups reachable with the same credentials as production. That is what allowed the deletion on day 20. Tip: a separate account, locked retention and backup credentials production does not know.
  • Confusing high availability with backup. The replica replicates the errors. Tip: always ask yourself "and what if somebody deletes the table?".
  • Encrypting the backup and keeping the key inside the encrypted environment. Tip: separate custody and a tested key recovery procedure.
  • Backing up the data and not the configuration. Restoring a database without being able to stand up the infrastructure stretches the RTO by days. Tip: versioned infrastructure as code, and in the backup too.
  • Retention that is too short. Corruption discovered three weeks later is already in every copy. Tip: tiered daily/weekly/monthly/annual retention.
  • A plan that exists only in the system that can go down. Tip: a printed, out-of-band copy, just like the response plan.
  • Forgetting the BCP. A perfect DRP leaves the business at a standstill for the duration of the RTO. Tip: start with the daily diary export; it is almost free.

Exercises

Exercise 1 — From the BIA to the architecture

Nimbus wants to launch a teleconsultation module for the clinics. The business estimates that if the module goes down, the clinics can reschedule by phone, but more than 2 hours of outage during the morning means losing the day's consultations, and that losing the records of a consultation already carried out is unacceptable because they are clinical data.

  1. Set the module's MTPD, RTO and RPO, justifying them.
  2. Choose the technical strategy using the table in section 3 and state the relative cost.
  3. Propose two graceful degradation measures that reduce the per-hour impact without moving up a cost rung.

Exercise 2 — Diagnosing a test report

This is another company's last restore test report:

test: quarterly_restore
date: 2026-03-01
source_backup: "s3://backups/postgres/latest.dump"
hash_verified: false
duration_minutes: 38
rto_target_minutes: 60
rows: {appointments: 412000}
result: PASS
findings: []
next_test: "2026-06-01"

Identify everything that makes this report fail to demonstrate that the company can recover, and rewrite the fields that are missing.

Exercise 3 — Recalculating the RTO for the ransomware scenario

Nimbus has committed to an RTO of 4 hours for the API and the database, measured in the quarterly test (55 minutes). Estimate the real RTO in the face of ransomware like the 02-06 incident by breaking it down into phases, say where most of the time sits and propose three measures that would reduce it. Finish by saying what Marta should do about the 4-hour commitment.


Solutions

Exercise 1

(1) MTPD = 2 hours, because that is the limit the business sets before harm that cannot be repaired (the day's consultations are lost). The RTO must be less than the MTPD, so it is set at 1 hour, leaving room for detection and the decision, which also consume MTPD — a very common mistake: setting RTO = MTPD and then discovering that the time to detect and decide had already used it up. The RPO ≈ 0-5 minutes, because losing the record of a consultation already carried out is unacceptable: it is clinical data that may also have evidential value.

(2) With an RTO of 1 h and an RPO of minutes, the table in section 3 places the solution at asynchronous replication to another zone with manual promotion (× 2), not at synchronous replication (× 3-4). Asynchronous replication with a lag of seconds meets a 5-minute RPO comfortably, and manual promotion fits within 1 hour if the procedure is written down and tested. Paying for synchronous here would be over-engineering: the RPO required is not zero, it is "minutes", and that distinction is worth twice the cost.

(3) Two graceful degradation measures: (a) have the teleconsultation application save the notes of the consultation in progress locally on the practitioner's device and synchronise them on recovery, so that an outage does not destroy work already done — this reduces the impact of the RPO without changing the data architecture; and (b) a degraded mode in which, if the video service fails, the platform still lets you view the record and log the consultation, offering an alternative phone link: the business process is preserved even though its most expensive component has failed. Both reduce the per-hour impact in the BIA and neither moves up a cost rung.

Exercise 2

Problems with the report:

Problem Why it invalidates the test
hash_verified: false Integrity was not checked: something was restored that may be corrupt and nobody knows
source_backup: ".../latest.dump" The most recent backup was tested, which is the one most likely to work. An honest test also uses a copy from weeks ago, which is the one you will need in the face of silent corruption
Only a row count, with no comparison against production 412,000 rows could be the total... or half of it. A number with no reference verifies nothing
No referential coherence check A partial restore would pass this control
No rpo_actual You do not know up to what moment the restored data reaches, which is exactly what the RPO promises
findings: [] Suspicious: a real test almost always finds something. It suggests the easy path was run, or that nothing was documented
It does not say who ran it or whether the written procedure was sufficient If only Lucía knows how to do it, the RTO is not met when Lucía is on holiday
It does not say whether the test environment was destroyed A forgotten environment with real data is an uninventoried asset

Missing fields: hash_verified: true, backup_tested: {recent: ..., old: ...}, rows: {appointments, customers, orphans} with deviation_vs_production_pct, rpo_actual, executed_by and procedure_sufficient: true|false, environment_destroyed: true, findings with at least one observation and actions with an owner and a date.

Exercise 3

Breakdown of the real RTO in the face of ransomware:

Phase Estimated time Comment
Detection and declaration 1-4 h With no detective controls, it can be days (20 in 02-06)
Containment and scope assessment 4-12 h You have to know what is compromised before restoring on top of it
Rebuilding the infrastructure from scratch 8-24 h The longest phase if there is no infrastructure as code
Data restore 1 h The only measured figure: 55 minutes
Validation, reconciliation and return 4-8 h Checking integrity and the data between the RPO and the disaster
Realistic total ~2-3 days Against the 4 hours committed

Most of the time is not in restoring, but in rebuilding and in trusting. Restoring is 3 % of the total; the remaining 97 % is discovering the scope, standing up a clean environment and verifying that you can go back.

Three measures that genuinely reduce it: (a) complete and tested infrastructure as code, which turns the 8-24 hours of rebuilding into 1-2 hours of applying a template — by some distance the highest-impact measure; (b) detective controls (C-08, C-09 from 04-03), which cut the detection phase from days to hours and also reduce the scope to be investigated; and (c) a prepared recovery environment in a separate account, with the network and the roles already defined, so you do not have to create it under pressure.

What Marta should do about the 4-hour commitment. Not leave it as it is. She has three defensible options and one unacceptable one. She can qualify the commitment — 4 hours for technical failure, a different, declared objective for security compromise scenarios, which is what serious providers do; she can invest in infrastructure as code and a prepared recovery environment to bring the ransomware scenario closer to 4 hours; or she can formally accept the risk with a management signature and an expiry (04-01) while she does the above. What is unacceptable is leaving the number as it stands in the contract: an RTO committed to and not achievable is a breach of contract waiting for its date, and it also falsifies the residual risk in the register.


Conclusion

You have closed the module with the discipline that decides whether the company survives. You distinguish BCP and DRP as complementary and not interchangeable plans — the business carrying on versus the technology coming back — and you know that for an SME "disaster" does not mean earthquake: it means ransomware, mass deletion, a provider outage or a corrupt migration. You know how to build a BIA by identifying business processes and not systems, with its MTPD set by the business and not by technology, measured in bands because impact is not linear, and with the observation that reorders priorities: at Nimbus the most critical process by availability is not the one handling the most sensitive data.

You have RTO and RPO — how long you take to come back and how much data you lose — their relationship with the MTPD, the table that translates each objective into a technical strategy and a relative cost, the difference between asynchronous and synchronous replication, and the rule that avoids the circular conversation: they are derived from the BIA and, if the budget does not reach, the gap is documented as an accepted risk with a signature, you never change the number on the sheet. You know the backup strategies — full, incremental and differential — and the 3-2-1-1-0 rule digit by digit, with the last two digits as the protagonists because they are exactly the ones Nimbus was missing in 02-06: the 1 for immutable, which only counts if the retention is locked and the backup credentials are unknown to production, and the 0 for verified. You know what else has to be backed up besides the data — configuration, infrastructure as code, secrets, certificates and the recovery documentation itself — and what a backup does not cover: replicated logical deletion, propagated corruption, data that lives only in a SaaS and schema changes.

You take away the heart of the lesson: an unverified backup is not a backup, it is a hope, with the four types of test, a restore script for an isolated environment that times the real RTO, verifies the hash before restoring, compares row counts against production, checks referential coherence and destroys the environment at the end, and a report in which the findings field is what justifies the exercise. You know why ransomware breaks the classic plans — reachable backups that get encrypted, rebuilding rather than restoring, a multiplied RTO and confidentiality that cannot be recovered — why high availability is not a backup — it replicates the DELETE with the same diligence — and what graceful degradation contributes. And you have the written plan: the start-up order by dependencies with its two warnings, the manual emergency procedures headed by the most profitable idea in the lesson — the daily diary export each clinic already has in its inbox — the complete DRP template, the testing cadence with the quarterly partial drill as the non-negotiable piece, and the metrics, among which coverage always reveals some critical system nobody was backing up.

With this, Module 4 is complete and forms a system. You know what to protect and in what order of priority, through a defensible risk assessment with its living register, its signed appetite and its four treatment strategies (04-01). You know under what rules, with a document hierarchy that makes decisions outlive whoever took them and an exceptions register with mandatory expiry (04-02). You know with what measures, with a control catalogue classified by nature and by function, measured by coverage and not by existence, and traced through to its evidence (04-03). You know how far your perimeter reaches, with a third-party map, proportionate due diligence, contractual clauses and the software supply chain (04-04). You know how to react, with a plan written beforehand, preserved evidence, honest communication and a blameless post-mortem (04-05). And you know how to come back, with objectives derived from the business and verified backups (04-06).

But notice one word that has appeared in all six lessons without ever being developed: verify. The control catalogue requires you to check that MFA covers 100 % of accounts; the monthly external scan has to discover whether port 5432 has been reopened; the exfiltration alerts have to exist and fire; the per-tenant authorisation tests have to run on every merge; and somebody has to actively look for the vulnerabilities before the attacker does. All of that is technical work with specific tools that this module has named without teaching.

In Module 5: Security Tools and Techniques we move from management to execution: vulnerability analysis tools (05-01) to find what is exposed, monitoring and detection techniques (05-02) to finally build the detective controls Nimbus lacks, penetration testing (05-03), network security (05-04), application security (05-05), endpoint hardening (05-06) and cloud and container security (05-07). We stop asking what is worth protecting and start checking, with tools in hand, whether it really is protected.

Fundamentals of Information Security Course

Module 1: Introduction to Information Security

Module 2: Cybersecurity

Module 3: Cryptography

Module 4: Risk Management and Protection Measures

Module 5: Security Tools and Techniques

Module 6: Best Practices and Regulations

Module 7: Final Project

© Copyright 2026. All rights reserved