Skip to content
Velloreth
Cybersecurity 10 min read

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

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:

ScenarioTypical triggerFirst containment action
Compromised account (hosting, cloud, registrar)Unexpected resources, billing spike, unfamiliar IPs in logsRotate credentials, revoke sessions, review IAM keys
Exposed secret (API key, token in git)Secret scanner alert, unexpected API usageRevoke the key at the provider, then scrub history
Data exposure (public bucket, exposed admin panel)Researcher email, misconfiguration scan, or you noticingMake it private, rotate anything inside, assess scope
Ransomware / destructive malwareFiles renamed, encryptor message, mass deletionsIsolate the machine, do not pay, restore from backups
Dependency compromiseCVE in a package you use, unexpected postinstall behaviorPin 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:

  1. Restore from backups where the data was tampered with.
  2. Bring services up with logging verified and credentials fresh.
  3. 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:

  1. Find the key in your secret scanner output or CloudTrail.
  2. Disable it in IAM immediately.
  3. Check CloudTrail for actions taken with that key in the preceding days.
  4. Identify what resources the key’s policy allowed.
  5. Rotate any other secrets with similar scope.
  6. Fix the leak (scrub git history with git filter-repo or 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:

  1. Close public access; confirm with a scan from outside.
  2. Determine whether data was read (connection logs, access logs).
  3. Inventory what was in the database (users, payments, private messages?).
  4. Decide, using your pre-written rules, on notification.
  5. Rotate database credentials and any application secrets the database contained.
  6. 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:

  1. Can they still get in? (Containment)
  2. What did they see or change? (Scope)
  3. 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:

  1. What happened, in one or two sentences, without minimizing.
  2. What data was involved, as specifically as you can state it at the time.
  3. What you have done — credentials rotated, service restored, access revoked.
  4. What they should do — change a password, watch for a specific kind of message, or nothing if nothing is required of them.
  5. 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.

Frequently asked questions

How do I know if I am actually in an incident?
If production data or access may be in the wrong hands, or your systems are behaving in ways you did not change, you are in an incident — even before you understand what happened. Treat uncertainty as an incident and downgrade later; the reverse costs you the containment window.
What should I do first when I suspect a compromise?
Contain: rotate or revoke the credentials you believe are involved, block the offending IPs or sessions, and snapshot the affected systems for forensics. Do not start deep debugging until the attacker's access is cut off — otherwise you are debugging while they continue working.
Do I need to notify anyone after a data breach?
It depends on your jurisdiction and who was affected. Many US states, the EU's GDPR, and other regimes have statutory notification timelines — often 72 hours for regulator notification. If you have paying customers, check your contracts too; many contain breach-notification clauses independent of law.
Is a written incident response plan realistic for one person?
Yes, if it is one page. List your critical systems, the order you will contain them, key contacts (hosting, registrar, legal), and the decision rules you committed to while calm. A plan you can read in two minutes beats a document you cannot find during the outage.