Incident Response for Solo Developers
You are the SOC, the on-call engineer, and the communications team. A practical incident response playbook for developers who work alone.
By Velloreth
An incident response plan assumes a security team, a communications lead, and a legal contact. When you work alone, you are all three, and the first incident you face will teach you that in the worst possible way — at the moment you can least afford to learn. The good news: solo incident response is a skill you can build in advance with about a day of preparation, and the failure mode you are protecting against is not “lacked enterprise tooling,” it is “froze, or fixed the wrong thing first.”
This is a practical playbook for the developer who is the entire security function.
What an incident actually looks like for you
Enterprise incident response books catalog dozens of attack types. For a solo developer or a tiny team, the realistic set is short:
| Scenario | Typical trigger | First containment action |
|---|---|---|
| Compromised account (hosting, cloud, registrar) | Unexpected resources, billing spike, unfamiliar IPs in logs | Rotate credentials, revoke sessions, review IAM keys |
| Exposed secret (API key, token in git) | Secret scanner alert, unexpected API usage | Revoke the key at the provider, then scrub history |
| Data exposure (public bucket, exposed admin panel) | Researcher email, misconfiguration scan, or you noticing | Make it private, rotate anything inside, assess scope |
| Ransomware / destructive malware | Files renamed, encryptor message, mass deletions | Isolate the machine, do not pay, restore from backups |
| Dependency compromise | CVE in a package you use, unexpected postinstall behavior | Pin to a known-good version, audit transitive deps |
Notice what is missing: the exotic, weeks-long intrusions. Those make headlines, but your probability-weighted risk is a leaked key, an open database, or an account takeover. Prepare for those first.
The posture you build before anything happens
1. One page of written decisions
Write this today, while nothing is wrong. It is not a 40-page IR plan. It is:
- Critical systems list: domain registrar, DNS, cloud accounts, database, email, code host, payment processor. For each: where it is, who supports it, how you log in.
- Containment order: which credential or system you will kill first if you have to choose. (Usually: the compromised identity, then the affected data store, then the public-facing app.)
- Contacts: support tickets/phone for your registrar, cloud provider, and email host — saved somewhere you can read when your password manager is the thing that is compromised. (Printed, or in a second password manager under a different primary.)
- Decision rules: pre-committed answers to the questions you will face under stress. “If data may have been exfiltrated, I notify affected users within 72 hours.” “I do not pay ransomware demands.” “I engage a lawyer before admitting fault publicly.”
Pre-committed rules are the whole value of the document. Under pressure you will not have the judgment to invent good policy; you will have the judgment to follow a rule you wrote when calm.
2. Logging you can actually read
You cannot respond to what you cannot see. For a solo developer, minimum viable logging:
- Cloud and hosting admin activity. AWS CloudTrail, GCP Audit Logs, or equivalent — at minimum alert on root/admin login and IAM changes.
- Application errors and access logs with enough retention (30–90 days) to answer “when did this start?”
- DNS and registrar change history. Domain hijack is a common and brutal solo-dev scenario.
- Git audit events on your code host for secret-push and permission changes.
Ship logs off-box. If the attacker is on your server, local logs are theirs to edit.
3. Backups that you have restored
A backup you have never restored is a hope, not a backup. The test is simple and uncomfortable: once a quarter, restore your database (or your most critical dataset) into a scratch environment and verify it is complete and usable. Time it. If a restore takes eight hours, your stated recovery time objective is fiction, and you should either fix the process or change the number you tell yourself.
Keep at least one backup copy in a separate account or provider, with credentials that are not the same as production. Ransomware that reaches your cloud account will take same-account backups with it.
4. An incident channel with yourself
Set up, in advance:
- A notes document template: timeline, decisions, evidence locations.
- A way to keep working if your primary machine is compromised — a second device, or at least a live USB environment.
- A public status page or simple “system status” post location if you have users who need to know.
The response sequence
When something feels wrong, run this order. Resist the urge to jump to root-cause analysis first.
Step 1: Contain (minutes, not hours)
Cut the attacker’s access before you understand the attack:
- Rotate or revoke the credentials involved — API keys, passwords, SSH keys, OAuth tokens.
- Terminate sessions: “sign out all sessions” in your identity provider, revoke OAuth grants.
- If a host is actively compromised, isolate it (network quarantine or shutdown) and work from a clean machine.
- Snapshot affected systems before you modify them, if you can do so safely — snapshots are cheap and forensics later is not.
The common solo-dev mistake is spending two hours staring at logs while the key you already suspect is still active. Revoke first; the logs will still be there.
Step 2: Assess scope (hours)
With access cut, answer:
- What data or systems were reachable with the compromised credential?
- When did the suspicious activity start? (Your logs, plus the provider’s audit trail.)
- Did anything leave the environment? (Egress logs, object-download records, unusual API calls.)
- Is anything else affected — other accounts using the same password, other systems on the same host?
Write the timeline as you go. Your postmortem and any notification obligations depend on it, and memory degrades fast during an incident.
Step 3: Eradicate and fix (hours to a day)
Now remove the root cause:
- Close the vulnerability that let them in — misconfigured security group, exposed admin panel, unpatched dependency, phishing-replayed session.
- Rebuild rather than clean when the compromise is deep (malware on a host, a fully-owned account). Rebuilding from a known-good image is faster than proving something is clean.
- Rotate every credential that was reachable, not just the one you know was used. Attackers rarely stop at the first key.
Step 4: Recover
Bring systems back in stages:
- Restore from backups where the data was tampered with.
- Bring services up with logging verified and credentials fresh.
- Watch closely for 48–72 hours. Recurrence is common when the attacker retained a second access path.
Step 5: Notify, if required
If personal data was exposed, you likely have legal obligations. Common rules:
- GDPR (EU/EEA data): supervisory authority notification within 72 hours of becoming aware, and often data-subject notification.
- US state laws: most states now have breach-notification statutes with their own timelines and definitions of personal information.
- Contracts: many SaaS and enterprise customer agreements require notification on a schedule independent of law.
When in doubt, notify affected users honestly and early. Under-disclosure discovered later is almost always worse than the original incident.
Step 6: Postmortem, blameless and written
Within a week, write one document:
- What happened (timeline).
- What the impact was (data, downtime, money).
- What let it happen (the actual root cause chain).
- What you changed, with dates.
No blame — you are both the responder and the author of the system that failed. The document’s only purpose is to make the next incident less likely and faster to contain. Share it with anyone affected if appropriate; a candid postmortem builds more trust than silence.
Two scenarios worth rehearsing
You cannot rehearse every incident. Two are worth an hour each.
Rehearsal 1: “My AWS access key leaked”
Walk through it on paper, or in a sandbox account:
- Find the key in your secret scanner output or CloudTrail.
- Disable it in IAM immediately.
- Check CloudTrail for actions taken with that key in the preceding days.
- Identify what resources the key’s policy allowed.
- Rotate any other secrets with similar scope.
- Fix the leak (scrub git history with
git filter-repoor BFG, revoke and re-issue).
Time yourself. Most people discover their actual procedure has a gap — usually “I would not know where to find the key’s usage history.”
Rehearsal 2: “My database was public on the internet”
Rehearse:
- Close public access; confirm with a scan from outside.
- Determine whether data was read (connection logs, access logs).
- Inventory what was in the database (users, payments, private messages?).
- Decide, using your pre-written rules, on notification.
- Rotate database credentials and any application secrets the database contained.
- Add a pre-commit or CI check so the misconfiguration class cannot recur.
The mental model that helps
During an incident, three questions organize everything:
- Can they still get in? (Containment)
- What did they see or change? (Scope)
- How do I make sure it cannot happen this way again? (Eradication and prevention)
If you find yourself deep in question 2 while question 1 is unresolved, stop and answer 1. That single discipline — contain before you understand — is the difference between a bad evening and a bad quarter.
A timeline template you can paste into
When the incident starts, open a document and fill this in as you go. Do not wait until the postmortem to reconstruct it from memory.
# Incident: [short name]
Started: [YYYY-MM-DD HH:MM TZ]
Detected by: [alert / user report / self]
Severity: [data exposed? / downtime? / money at risk?]
## Timeline (UTC)
- HH:MM — first signal observed
- HH:MM — containment action taken (credential revoked / host isolated)
- HH:MM — scope assessment: what was reachable
- HH:MM — evidence snapshot taken
- HH:MM — eradication complete
- HH:MM — service restored
## Decisions
- [Decision + rule it came from, e.g., "Notified affected users — per breach notification policy"]
## Open questions
- [ ]
Two properties make this work: timestamps are recorded at the moment of action, not reconstructed later, and every decision names the pre-committed rule it came from. If you cannot name a rule, that is a signal you are making a judgment call under stress — write down why.
If you need to tell users something
Keep the first notification short, factual, and free of speculation. A structure that works:
- What happened, in one or two sentences, without minimizing.
- What data was involved, as specifically as you can state it at the time.
- What you have done — credentials rotated, service restored, access revoked.
- What they should do — change a password, watch for a specific kind of message, or nothing if nothing is required of them.
- Where updates will appear and a contact address for questions.
Send it before you have every detail if the notification clock (legal or practical) requires it, and say what you do not yet know. A later correction to an honest first message costs less trust than silence discovered later.
Incident response as a solo developer is not a scaled-down version of the enterprise process. It is a smaller, sharper set of habits: a one-page plan, logging you can read, backups you have restored, and the discipline to revoke credentials before you start debugging. None of it requires a security team. All of it has to be built before the night you need it.