Home › Topics › Incident Response › Small-Team Command

Incident Command for Small Teams


"Incident command" sounds like something for organizations with badge readers and a war room. It sounds like a framework invented for wildfires, borrowed by enterprises, and surely absurd for an IT team of three. Most of the ceremony is skippable. But buried inside it is one insight that scales all the way down to two people, and even to one. It is this: someone owns the response, and roles beat scrums.


The scene that insight prevents goes like this. A server dies and five capable people converge on it, a huddle of goodwill, everyone typing, nobody in charge. Two of them apply different fixes to the same box at the same moment. Nobody has told the users anything. A decision gets made because one person said it loudest, and an hour later nobody can say what was changed, when, or why. Five responders, zero owners. The outage was survivable. The response is what made it memorable.


This guide is incident command with the enterprise starch washed out. It covers the two-role minimum that fixes the huddle and an honest rhythm for running incidents alone. It covers how the structure stretches to five people and what to do when the boss arrives. It covers the small practices (one channel, a recap ritual, a decision log) that make the whole thing feel light instead of bureaucratic. I have run incidents both ways. The commanded ones were not always shorter. They were the ones I could explain afterwards.


In this guide

  • Why structure beats swarming
  • The two-role minimum: driver and communicator
  • Running it solo: two hats and a timer
  • Three to five people: helpers with owned tasks
  • When leadership arrives
  • The command practices that keep order
  • Declaring structure in one sentence
  • The same outage, swarmed vs. commanded
  • The role cards

Why structure beats swarming


Swarming feels right. Everyone cares, everyone helps, all hands on deck — what could be wrong with that? Three specific things, each with teeth. I have sat on a bridge call with nineteen people on it. It made no decisions, but it made them unanimously.


Parallel uncoordinated changes. Two people fixing the same problem independently is not twice the fixing; it is a new problem. One admin restarts the database service at the exact moment another reboots the host under it. One fails traffic over to the standby while another is mid-way through repairing the primary. Now the system's state is the product of two overlapping interventions. Symptoms have changed for reasons nobody understands, and diagnosis has to start over — on a moving target. The two-fixes-collide disaster converts one incident into two and destroys the evidence of both.


Nobody communicates. In a huddle, communication is everyone's job, which makes it nobody's. Every person assumes someone else surely told the users. The users, hearing nothing, conclude nobody is working on it — while five people are. Psychologists call this diffusion of responsibility: the more people share an unassigned duty, the less likely anyone performs it. It is the same failure that makes "somebody should watch the alerts" fail as a plan. That is the reason on-call schedules name one person, as covered in Escalation & On-Call. Duties without names quietly evaporate, and incidents are made of duties.


Decisions by loudest voice. With no designated decider, calls get made by volume, seniority, or whoever types fastest — and reversed the same way. The huddle can spend twenty minutes relitigating whether to restore from backup while the outage ages politely in the background.


Structure fixes all three with almost no machinery: name who owns what, and the collisions, the silence, and the shouting matches lose their habitat.


If anything, small teams need the naming more than enterprises do, not less. A big organization can absorb a botched response — there are spare engineers, spare goodwill, and a process team to write the memo. A three-person shop has no slack. The colliding fix costs the only afternoon, and the missed communication burns trust with the only user base. Every responder is also the person who must fix whatever the response broke. Structure is not overhead that small teams cannot afford; it is insurance that only costs a sentence.


At Ashgrove Housing the tenant portal stopped responding at 8:50 on a rent-due Monday, and all three admins went at it at once. One restarted the web service, one rebooted the host underneath it, and one failed the database over to its standby. All of this happened inside the same four minutes, with none of them knowing about the other two. The portal came back at 9:40 and nobody could say which change had done it. So all three were written into the runbook as the fix. The only person who could reconstruct the morning was the apprentice. She had been told to "just keep notes" and had done so, with timestamps. She has run the channel on every incident since. The team calls this "letting the apprentice run it", and it works.


The two-role minimum: driver and communicator


Two people are enough for real incident command, split not by taking turns but by role. The driver owns the technical response: hands on keyboards, runs the diagnosis, decides the next technical move, makes the changes. The driver is the only one making changes. The communicator-scribe owns everything else. This person sends the user and leadership updates on cadence and keeps the timeline notes — timestamps, actions, results. Crucially, this person shields the driver by absorbing every interruption. Status questions, ticket pings, the anxious manager: all of it lands on the communicator and none of it reaches the driver.


Why this particular split? Because the driver's focus is the scarcest resource in the room. Deep diagnosis means holding a fragile tower of state in your head — which changes were made, which hypotheses died, what that log line implied. Every "any update?" knocks the tower over, and rebuilding it takes minutes each time. The communicator role exists to spend cheap attention protecting expensive attention. It is why the hovering-boss problem from outage communication has a structural answer, not just a diplomatic one. The boss gets a dedicated human, and the driver gets silence.


Who takes which role? The person who knows the failing system best drives — not the most senior person, and not whoever saw the alert first. Seniority is a fine tiebreaker and a terrible default, because the structure exists to put the scarcest knowledge at the keyboard. And the roles can swap mid-incident. When the diagnosis wanders from the network into the database, the network person can hand the driving to the database person. That handoff happens out loud, in the channel ("Ana driving as of 10:15"), so there is never a moment with two drivers or none.


Two warnings from the field. The communicator role is not the junior consolation prize. Done well it requires judgment (what to say, to whom, when). It is the role users and leadership will grade the whole response by. And the driver must actually surrender the communication. A driver who pauses mid-diagnosis to reword the user notice is paying the exact focus tax the structure exists to avoid.


Running it solo: two hats and a timer


Many readers are the whole IT department. The honest solo version is that you cannot split the roles, but you can alternate them on a timer instead of letting adrenaline choose. Drive for twenty-five minutes, hands on the problem, interruptions ignored. Then stop — genuinely stop — and spend five minutes wearing the communicator hat. In those minutes, send the promised update and add timestamps to the thread. Note what you tried and what you ruled out. Glance at scope in case it moved. Then back to driving.


The rhythm feels artificial and works precisely because it is. Without it, solo responders default to one of two failure shapes. There is the silent deep-dive (three heroic hours, zero updates, furious users). Or there is the ping-pong (so many interruptions that diagnosis never gets ten consecutive minutes). The timer guarantees both jobs happen and neither devours the other. Twenty-five and five is a starting ratio, not scripture — a SEV-1 with a thirty-minute update cadence maps onto it naturally.


Your other teammate is paper: the checklist stands in for the colleague who would otherwise catch your skipped step. The first-fifteen-minutes card is the co-pilot for the opening; the role cards at the end of this guide cover the long middle. Solo response is not the absence of structure — it is structure externalized onto timers and cards, because there is no second brain to hold it.


One more solo trick: borrow a second brain by phone. Before an irreversible action — the restore, the delete, the failover — call a colleague, a friendly peer at another shop, or the vendor's support line. Narrate the plan out loud. You are not asking them to fix it; you are renting the second-opinion ritual. Half the time, the act of narrating exposes the flaw before the listener says a word. (The listener's job is to say "go on". It is a more skilled job than it sounds.)


Three to five people: helpers with owned tasks


Add a third, fourth, or fifth person and the temptation to huddle returns. Resist it the same way: everyone slots under the two-role spine. The driver stays singular. Extra hands become helpers with owned workstreams, assigned by the driver in one sentence each: "You check whether last night's backup completed. You trace the path from the branch to the firewall. Report back here in ten." Tasks are owned, not shouted — a named person, a defined question, a report-back time. Helpers work their lane without freelancing changes on the side. The moment a helper starts applying fixes unbidden, you have a huddle again, just with extra steps.


Helpers also unlock the second-opinion pattern for frightening actions. Before anything irreversible — restoring over live data, deleting, failing over storage — the driver states the plan out loud. A helper repeats it back. What are we about to do, to which system, and what do we expect to happen? Thirty seconds of ritual, and it catches wrong-server moments with embarrassing regularity. It is the same spirit as the two-person rule that good runbooks build into their destructive steps.


Who breaks ties when the driver and a helper disagree? Formally, that is the incident lead. At this scale, the driver usually is the lead. The rule is simply: debate for two minutes, then the driver decides and everyone rows in that direction. A mediocre decision executed together beats two good decisions executed simultaneously.


When leadership arrives


At some point during a visible incident, a manager or executive appears, radiating urgency. This is a good moment badly handled by default. Unmanaged, the arrival converts your commanded incident back into a huddle chaired by the person who has just walked in. Managed, it adds the one thing your structure lacks — authority. The manager is not the problem. The vacuum they walked into is, and you can fill it in two sentences.


Leadership's real jobs during an incident are the decisions above the technical. These include authorizing emergency spend (overnight parts, a consultant's rate card) and owning communication to customers or partners. They include calling business priorities ("payroll first, ship the orders tomorrow") and settling escalation questions no admin should carry alone. What leadership must not do is drive — grab the keyboard, redirect the diagnosis, or turn the incident channel into a status meeting. The best version of this arrangement is negotiated in daylight. Agree before the year's first bad day what the responder may spend or decide without asking. That way, the 2 a.m. incident does not stall waiting for a purchase approval nobody can wake.


The redirect is kindest when it arrives as a job offer plus a promise: "Here's where we are — two-minute version. What I need from you is [the spend approval / the customer message / the priority call]. Updates every thirty minutes from Dana, and the first one is in ten." You have given them a role, a channel, and a cadence — which is all most executives were pacing around looking for.


The command practices that keep order


Three small practices carry the whole structure, and all of them fit in a chat thread.


One channel, everything in it. The incident gets a single workspace the moment it is declared — a chat channel or thread named for it. The response lives there: facts as they land, decisions as they are made, screenshots and evidence links, all timestamped. Not spread across three DMs, a phone call, and somebody's notepad. The single channel is what lets a newcomer join by reading instead of by interrupting. The scribe's running log becomes, nearly verbatim, the timeline the post-incident review will otherwise spend an hour excavating.


The state-of-play recap. At intervals — every thirty to sixty minutes, and always at a handoff — the driver or scribe posts a two-minute recap. It covers what we know, what we have ruled out, what is in flight, who owns what, and the next decision point. The recap keeps helpers aligned without a meeting. It catches the drift where two people quietly hold different theories of the incident. It turns shift changes on long incidents from folklore transfer into a clean read-and-confirm. (Handing work between people without dropping it is a discipline of its own — see Escalation & On-Call.) A real one looks like this:


RECAP 11:30 (Ben)
Know:      branch VPN down since 9:02; primary appliance wedged, standby carrying traffic since 9:25
Ruled out: ISP link (clean pings), certificates (valid), config change (none since Tue)
In flight: Ana reading appliance crash log; vendor case #48731 opened
Owns:      Ana=diagnosis, Ben=comms (next user update 12:00), Cho=watching standby load
Next call: 12:30 — if crash cause unclear, leave standby in place and schedule primary swap

The decision log. Big calls get one deliberate line as they happen: "16:40 — restoring from last night's backup rather than repairing; repair estimate exceeded two hours and confidence was low." Tried X, because Y. It takes ten seconds, prevents the same option being re-argued at hour three, and is pure gold at review time. It is the difference between "why on earth did we restore?" and a recorded answer.


Tip: the scribe is not a court stenographer. Capture timestamps, actions, decisions, and evidence links — not dialogue. Five terse lines an hour beats a transcript nobody will read, and it is exactly the skeleton the review needs.


Declaring structure in one sentence


None of this requires a form or a meeting. The whole apparatus starts with one line said out loud or typed into the new channel: "I'm driving; you're comms; Sam, check the backups." That is the ten-second org chart — roles exist because someone said them. Everyone now knows whose hands are on the keyboard and whose voice faces the users. The severity call decides when this line is worth saying. A SEV-3 ticket needs no declaration, while a SEV-1's all-hands contract is precisely a promise that roles will be dealt fast.


And like everything else in incident response, it improves with rehearsal. Once or twice a year, run a tabletop drill: invent an outage, declare roles, speak the recaps, log the decisions — twenty minutes, coffee included. The first real incident after a drill runs noticeably smoother. Drills are also how you find out your response machinery is broken before it matters. That is a theme MTTD & MTTR takes further with measurement.


The same outage, swarmed vs. commanded


One outage, two universes. The VPN appliance — the box remote staff depend on — locks up at 9:00 on a Monday, with three IT people in the building:


TimeSwarmedCommanded
9:00All three converge on the appliance, standing, typing, theorizing.One line in a new channel: "Ana drives, Ben comms, Cho checks whether the standby is healthy."
9:10Nobody has told remote staff anything; helpdesk line starts ringing; whoever is nearest answers, differently each time.Ben's first notice is out: VPN down, we know, update by 9:40. Phones stay quiet.
9:20Person A reboots the appliance while person B initiates failover to the standby. The reboot interrupts the failover; now neither path works and the symptoms are new.Cho reports the standby healthy. Ana states the plan, Cho repeats it back, and only Ana acts: clean failover. Remote staff reconnecting by 9:25.
9:35Loudest voice wins a debate nobody logs; a config restore begins on a hunch, over the half-completed failover.Ben posts the recap: service restored via standby, primary quarantined for diagnosis, decision logged with reasons.
10:30Service limps back. Nobody can say which of five overlapping changes fixed it, so nothing is learned and the fear remains.Ana diagnoses the primary at leisure. The channel already contains the review's whole timeline.

Same failure, same people, same skills. The commanded version was not smarter — it was organized, ninety minutes faster, and it ended with knowledge instead of superstition. (It also ended properly, with verification before the all-clear — the discipline covered in ending an incident.)


The role cards


The structure, compressed for the wall. The communicator's row says "every interruption", and it means it: bosses count as interruptions, and the good ones know it. First, the roles:


RoleOwnsNever does
DriverDiagnosis, changes, technical decisions; states plans aloud before scary actionsUser updates mid-diagnosis; silent irreversible changes
Communicator-scribeUpdates on cadence, timeline log, absorbing every interruption including leadershipTouching production; promising ETAs the driver didn't give
HelpersOne named workstream each, with a report-back timeFreelance fixes outside their lane
LeadershipSpend, external comms, business prioritiesDriving; turning the channel into a status meeting

And the solo rhythm, for the department of one:


MinutesHatDo
25DriverHands on the problem; interruptions wait; scary actions get written in the thread first
5CommunicatorSend the due update; timestamp what was tried and ruled out; re-check scope; breathe
repeat—Adjust the ratio to the promised cadence; the timer, not adrenaline, changes the hat

Where to go next


You do not need the war room. You need one sentence at the start ("I'm driving; you're comms") and one channel that everything goes into. You need a recap every half hour and a line in the log for every big call. That is the whole of incident command at this scale, and it costs less time than the first collision it prevents. Five responders and zero owners is a huddle. Two responders and one owner is a team, and the team wins every time, badge readers or not.


Command is the connective tissue of incident response. It assumes a triage sequence to run (the first fifteen minutes). It assumes a severity call that says when to staff up (the working severity model). It assumes updates worth shielding the driver for (outage communication), and an ending done properly (verification and the all-clear). Declare roles in one sentence at your next incident and the rest starts falling into place. The full discipline lives at Incident Response.


Put this into practice with SysPeep Monitor

A driver and a communicator work best from one shared picture of the network, not two competing terminal windows. SysPeep Monitor puts live status, dashboards, and maps in a single web console. The driver watches the failing device, the communicator watches the blast radius, and both see the same facts. The free trial sets up on any Windows machine in minutes.

Download Free TrialLearn About SysPeep