Prove Your Data Recovery Skills with a Restore Drill
Make recovery judgment visible: restore a PostgreSQL backup into isolation, test business invariants and document exactly what the exercise cannot recover.
A backup file is a weak portfolio artifact. I would rather review a small recovery exercise that shows which data returned, which data did not, and how the application behaved afterward. For a full-stack developer, that is a useful way to demonstrate judgment beyond implementing another CRUD screen.
My proposed exercise is deliberately modest: restore synthetic PostgreSQL data into an isolated environment, connect a Node API and React interface, then test a written recovery contract. This is a learning project, not a claim about hiring demand or an account of a recovery I have performed.
Define what recovery promises
Start with a toy ordering application. Create customers, orders and order lines with known identifiers. Record expected totals and relationships in a fixture manifest outside the database. Choose a backup boundary, then add another synthetic order after the backup finishes.
Write the expected outcome before restoring: earlier fixture records should return; the later order should not. This makes the loss boundary inspectable instead of hiding it behind a successful import message. Avoid concurrent fixture writes during this first exercise so the expected snapshot is unambiguous.
PostgreSQL documents that pg_dump produces a consistent backup of one database, but does not include cluster-wide objects such as roles and tablespaces.1 I would therefore list application roles, required extensions and connection configuration as explicit prerequisites, not assume the archive represents the entire service.
Choose one recovery mechanism honestly
For the first drill, I would use a custom-format logical dump and restore it into a new, empty sandbox database. PostgreSQL supports restoring this archive format with pg_restore.1 Record server and client versions alongside the archive identifier. Keep credentials out of the public exercise log.
Do not describe that workflow as point-in-time recovery. PostgreSQL's continuous-archiving approach combines a physical backup with archived write-ahead logs, requiring an uninterrupted sequence of WAL files back to the backup's start. Logical dumps cannot supply that WAL recovery mechanism.2
That distinction is the tradeoff I would discuss in a portfolio review. A logical restore keeps the initial exercise bounded; a separate PITR drill would test recovery to a chosen point and the availability of its log chain. Neither label should imply evidence you have not collected.
Make the destination impossible to confuse
Use synthetic data and an isolated database instance with no production access. My runbook would print the destination host and database name, require an exercise-specific name, and stop if either differs from the allowlist. Disable outbound email, payment calls and background consumers before connecting the restored application.
Be careful with restore options: PostgreSQL documents that pg_restore --create restores into the database name stored in the archive, while its connection database is used to issue creation commands.3 For this exercise, I would pre-create the destination and restore directly into it without that option.
I would also use --exit-on-error and retain stderr. The documented default is to continue after SQL errors and report an error count at the end.3 Treat any failed restore as failed evidence; do not let a wrapper script turn a partial import into a green badge.
Verify the product, not just the tables
My acceptance checklist would compare fixture identifiers, order-line relationships and calculated totals against the external manifest. Check that the post-backup order is absent. Then authenticate through the Node API with the intended application role, read an order in React and create a new synthetic order.
Keep these assertions separate from basic process readiness. A listening server is not the outcome being demonstrated. Include a negative test: an account assigned to another synthetic customer must not read the restored order. Reviewing the PostgreSQL tenant boundary offers a useful companion exercise.
Record elapsed times only after running the drill, and define where measurement starts and ends. My preferred finish line is the last successful application assertion, not the moment the database accepts connections. Publish failures and unresolved prerequisites alongside successes.
Leave a reviewable recovery record
The final deliverable should contain the fixture manifest, sanitized commands, archive identity, observed checks and a limitations paragraph. State whether uploads, external services and deployment configuration were excluded. Distinguish expected outcomes from observed results throughout.
Rehearsing an application rollback tests a different boundary: restoring a version is not the same exercise as restoring data. Together, the two give a reviewer concrete decisions to question. Contact Argonaute Digital to review a recovery workflow or design a bounded restore exercise.