A green deployment and a quiet server do not prove that automation or hardening works: the backup may be unusable, and the firewall may never have been tested from outside. For a solo freelancer, I would judge these controls by whether they expose a failure in time to act and help you recover. A small, rehearsed check is worth more than a dashboard you cannot maintain.
A control is working only if it can fail visibly
The metric prompt (Is your DevOps automation working Check these 5 metrics) is useful, but I would not accept a metric merely because it is easy to collect: it must change a decision when something breaks. Deployment frequency, for example, tells a freelancer little about safety when client work arrives irregularly. A stronger question is whether a failed deployment stops, leaves the previous version available, and produces a message you will actually see.
Start with one failure you can create without harming a client. Point a staging deployment at an invalid configuration value and check whether the job exits nonzero. Then check whether the live service remains reachable and whether the failure reaches your usual inbox. Record the result and the time spent resolving it. If the job reports success despite the invalid value, the problem is not a missing graph; it is that the automation cannot distinguish a good release from a bad one.
Use the same approach for server hardening. The baseline checklist (Linux Server Hardening Checklist for Sysadmins) can help name controls, but a checked box does not show that the running OpenSSH server uses the setting you intended. On a server you administer, sshd -T shows effective configuration; add -C user=youruser,host=yourhost,addr=youraddress when Match rules could change the answer for a particular connection. Checking passwordauthentication and permitrootlogin in a file alone is weaker, because an included file or a conditional rule can override your expectation.
Configuration is still only one layer of evidence. From your laptop on a different network, use nmap -Pn -p 22,80,443 against your own server to see which intended ports are reachable. Run it again after a firewall change, because a local nftables ruleset does not prove what an external client can reach. Keep an existing SSH session open while testing a new login; otherwise, a successful lockout test could also lock you out.
I would not use the number of blocked SSH attempts as a hardening score, because internet scanning can raise or lower that count without any change in your exposure. I would instead check whether an unauthorized login method succeeds and whether the authorized method still works. Those two observations test both sides of the control.
Backup freshness is not evidence of recovery
A recently modified backup file proves that something wrote a file. It does not prove that the file contains the current database, that you possess the decryption key, or that you can restore it before a client needs the service. Treat the file timestamp as an inexpensive warning, then schedule a separate restore rehearsal as the actual test.
For a PostgreSQL application, pg_dump –format=custom produces an archive that pg_restore can read. Restore it into a disposable database, run a query that checks a known record or expected table, and note the start and finish times. pg_restore –list is a useful quick check of archive contents, but it cannot replace a restore because listing an archive does not exercise database creation, permissions, or application queries. If you copy archives with rsync, verify the destination copy rather than the source; the destination is the one you will need after the source server fails.
Give the rehearsal two limits before you run it. For example, choose 24 hours as an initial recovery-point objective only if losing a day of changes is acceptable for that client; this is a value to tune, not a universal target. Set a provisional 45-minute recovery-time objective if that is when a missed deadline would start causing damage. Then record the oldest restored record and the elapsed restore time. Those are observations you can compare with the limits, whereas “backup completed” is merely a job status.
Rehearse without overwriting production. If you have no spare server, a local PostgreSQL container or temporary database can test the archive and your instructions, although it cannot prove how long provisioning a replacement server would take. Write that limitation beside the result. A test is useful precisely because its scope is explicit.
Keep at least one backup outside the server it protects, because a compromised account or failed disk can affect local backups along with the application. Make sure you can retrieve it using credentials you still control when the server is unavailable. That access check costs little and answers a different question from whether yesterday’s scheduled job ran.
A local probe cannot tell you that its own server is gone
You can get useful signals without buying an observability stack. This Bash probe checks an HTTPS health endpoint with curl and reports the age of a specified backup file using GNU stat. Save it as probe.sh and run it with URL=https://your-site.example/healthz BACKUP=/path/to/latest.dump bash probe.sh. The endpoint should return HTTP 200 only when the application can perform a meaningful operation, because a static web-server response could remain green while the application is broken.
#!/usr/bin/env bash
set -u
: "${URL:?set URL to a health endpoint}"
: "${BACKUP:?set BACKUP to a backup file}"
now=$(date +%s)
if result=$(curl -fsS -o /dev/null -w '%{http_code} %{time_total}' --max-time 10 "$URL"); then
read -r status seconds <<< "$result"
else
status=000; seconds=0
fi
if stamp=$(stat -c %Y -- "$BACKUP" 2>/dev/null); then age=$((now-stamp)); else age=-1; fi
printf 'http=%s seconds=%s backup_age_s=%s\n' "$status" "$seconds" "$age"
(( status == 200 && age >= 0 && age < 86400 ))
The 10-second curl timeout is a configuration choice that prevents a hung request from holding the check indefinitely. The 86,400-second backup-age limit in the script is another adjustable threshold: change it to match your backup schedule and acceptable data loss. The final expression makes the script exit unsuccessfully when the endpoint fails or the file is missing or old, so a scheduler can notice the result. It does not establish that the backup will restore.
There is a practical choice between a systemd timer running curl on your server and an external UptimeRobot check. The timer wins for checking local files and commands because it can see them directly; its cost is setup and a small amount of server work, and it cannot report a total server outage from that same server. UptimeRobot wins for checking public reachability from elsewhere because it does not depend on your server staying awake; its cost is reliance on an external service, its account and notification settings, and whatever limits its current plan imposes. Neither replaces the other’s viewpoint.
Whichever route you choose, test the notification by making the check fail on purpose. A systemd timer showing recent runs is not enough if nobody sees its failures; inspect its exit status and journalctl output, then confirm the alert reaches you. An alert you never receive cannot shorten an outage.
The useful score is time to notice and time to recover
Keep a short log rather than a permanent dashboard. For each deliberate test or real incident, record the failure introduced, when it began, when you noticed it, what signal told you, when service was restored, and which data was lost. Those entries let you distinguish detection from repair. An illustrative rehearsal might take 12 minutes to notice a stopped service and 37 minutes to restore it; these would be measured results for that rehearsal, not promises about the next outage.
Review failures that produced no signal first. If a stopped service generates an external alert but a failed backup goes unnoticed, fix the backup notification before adding another uptime chart, because the existing blind spot threatens recoverability. If an alert arrives but its message omits the affected host or job, improve the message before making the check run more often, because faster ambiguous alerts still cost investigation time.
Do not mistake a clean month for proof. A quiet period may contain no meaningful challenge to your controls, so deliberately test one safe failure at a regular interval. A 20-minute monthly review is a reasonable starting time budget to adjust to your workload: trigger a failed check, inspect the alert path, and revisit the most recent restore record. When a test fails, change one control and repeat that test; otherwise, you cannot tell whether the change helped.
Start today by choosing one backup file and restoring it into a disposable database. Record what data it contains, how long the restore takes, and the first instruction you had to look up. That instruction belongs in your recovery notes. Once the restore works, deliberately fail one health check and confirm that its warning reaches you without relying on the server you are testing.


