Crisis communications Frameworks for accurate, rapid communication during high-pressure situations. When to activate Breaking news requires immediate coverage Organization faces public crisis or controversy Misinformation is spreading rapidly and needs countering Emergency situation requires coordinated communication Rapid fact-checking is needed before publication Preparing crisis response plans before incidents occur Breaking news protocol First 30 minutes checklist

Breaking news response

Event

[Brief description]

Time detected

[HH:MM]
**
Initial source
**: [Where we learned of this]

Immediate actions (0-10 min)

[ ] Verify event is real (minimum 2 independent sources)

[ ] Alert editor/team lead

[ ] Check wire services (AP, Reuters, AFP)

[ ] Monitor official accounts (agencies, officials)

[ ] DO NOT publish unverified claims

Verification phase (10-30 min)

[ ] Primary source contacted/confirmed

[ ] Location verified (if applicable)

[ ] Official statement obtained or requested

[ ] Eyewitness accounts gathered (note: unverified)

[ ] Social media claims flagged for verification

First publication decision

[ ] What we KNOW (confirmed facts only)

[ ] What we DON'T know (be explicit)

[ ] What we're working to confirm

[ ] Attribution clear for every claim Newsroom escalation matrix from enum import Enum from dataclasses import dataclass from typing import List class CrisisLevel ( Enum ) : LEVEL_1 = "routine"

Single reporter can handle

LEVEL_2

"elevated"

Editor involvement needed

LEVEL_3

"major"

Multiple reporters, editor oversight

LEVEL_4

"critical"

All hands, executive involvement

@dataclass class BreakingEvent : description : str level : CrisisLevel confirmed_facts : List [ str ] unconfirmed_claims : List [ str ] sources_contacted : List [ str ] assigned_reporters : List [ str ] def escalation_needed ( self ) -

bool : """Determine if event needs escalation.""" triggers = [ len ( self . unconfirmed_claims )

5 ,

Too many unknowns

"fatalities" in self . description . lower ( ) , "official" in self . description . lower ( ) , "government" in self . description . lower ( ) , ] return any ( triggers ) ESCALATION_TRIGGERS = { CrisisLevel . LEVEL_2 : [ "Multiple fatalities confirmed" , "Major public figure involved" , "Legal/liability concerns" , "Significant local impact" , ] , CrisisLevel . LEVEL_3 : [ "National news potential" , "Active danger to public" , "Major institution affected" , "Coordinated misinformation detected" , ] , CrisisLevel . LEVEL_4 : [ "Mass casualty event" , "Government/democracy implications" , "Our organization directly involved" , "Imminent physical threat" , ] , } Rapid verification framework The 5-minute verification When time is critical, prioritize these checks:

Rapid verification checklist

Source check (1 min)

[ ] Who is claiming this?

[ ] Are they in position to know?

[ ] Have they been reliable before?

Corroboration (2 min)

[ ] Does anyone else confirm?

[ ] Check wire services

[ ] Check official sources

Red flags (1 min)

[ ] Too perfect/dramatic?

[ ] Matches known false narratives?

[ ] Single source only?

Decision (1 min)

[ ] PUBLISH: Multiple credible sources, no red flags

[ ] HOLD: Needs more verification

[ ] MONITOR: Developing, don't publish yet Verification triage system from dataclasses import dataclass from datetime import datetime from typing import Optional from enum import Enum class VerificationStatus ( Enum ) : UNVERIFIED = "unverified" PARTIALLY_VERIFIED = "partially_verified" VERIFIED = "verified" DEBUNKED = "debunked" UNCERTAIN = "uncertain" @dataclass class Claim : text : str source : str first_seen : datetime urgency : int

1-5, higher = more urgent to verify

status : VerificationStatus = VerificationStatus . UNVERIFIED verification_notes : str = "" verifier : Optional [ str ] = None class VerificationQueue : """Manage claims awaiting verification.""" def init ( self ) : self . claims = [ ] def add_claim ( self , claim : Claim ) : self . claims . append ( claim ) self . _sort_by_priority ( ) def _sort_by_priority ( self ) : """Urgent claims first, then by time seen.""" self . claims . sort ( key = lambda c : ( - c . urgency , c . first_seen ) ) def next_claim ( self ) -

Optional [ Claim ] : """Get highest priority unverified claim.""" for claim in self . claims : if claim . status == VerificationStatus . UNVERIFIED : return claim return None def update_status ( self , claim : Claim , status : VerificationStatus , notes : str , verifier : str ) : claim . status = status claim . verification_notes = notes claim . verifier = verifier Crisis communication templates Holding statement For when you need to say something but facts are incomplete:

Initial statement template [Organization] is aware of [brief description of situation]. We are actively [gathering information / investigating / monitoring the situation]. [If applicable: The safety of [stakeholders] is our top priority.] We will provide updates as verified information becomes available. For media inquiries: [contact] For [ affected parties ] : [resource/hotline] Last updated: [timestamp] Correction/clarification

Correction notice
**
Correction [or Clarification]
**: An earlier version of this [ article/statement/post ] [ stated/implied ] [incorrect information]. [ If factual error ] : The correct information is: [accurate facts]. [ If misleading ] : To clarify: [accurate context]. This [article/statement] has been updated to reflect accurate information. We regret the error. [Timestamp of correction] Retraction (when necessary)

Retraction notice
**
Retraction
**: [Publication name] is retracting [article title], published on [date]. [ Brief explanation of what was wrong ] : Our reporting [ stated/relied on ] [ problematic element ] . Subsequent verification revealed [why it was wrong]. [ What you're doing about it ] : We have [removed/updated] the article and are reviewing our editorial processes. [ Accountability ] : We apologize to [affected parties] and our readers. The full text of the original article is available [here/on request] for transparency. Questions: [contact] Social media crisis response Monitoring during crisis from dataclasses import dataclass from datetime import datetime from typing import List , Dict from collections import Counter @dataclass class CrisisMention : platform : str content : str author : str timestamp : datetime sentiment : str

positive, negative, neutral, misinformation

reach : int

followers/potential impressions

requires_response : bool = False class CrisisMonitor : """Track crisis-related social mentions.""" def init ( self , crisis_keywords : List [ str ] ) : self . keywords = crisis_keywords self . mentions : List [ CrisisMention ] = [ ] def add_mention ( self , mention : CrisisMention ) : self . mentions . append ( mention ) def get_dashboard ( self ) -

dict : """Real-time crisis overview.""" recent = [ m for m in self . mentions if ( datetime . now ( ) - m . timestamp ) . seconds < 3600 ] return { 'total_mentions_1h' : len ( recent ) , 'sentiment_breakdown' : self . _sentiment_counts ( recent ) , 'top_platforms' : self . _platform_counts ( recent ) , 'misinformation_count' : len ( [ m for m in recent if m . sentiment == 'misinformation' ] ) , 'high_reach_negative' : [ m for m in recent if m . sentiment == 'negative' and m . reach

10000 ] , 'pending_responses' : len ( [ m for m in self . mentions if m . requires_response ] ) } def _sentiment_counts ( self , mentions : List [ CrisisMention ] ) -

Dict : return dict ( Counter ( m . sentiment for m in mentions ) ) def _platform_counts ( self , mentions : List [ CrisisMention ] ) -

Dict : return dict ( Counter ( m . platform for m in mentions ) ) Response decision tree

Should we respond to this?

High priority (respond quickly)

[ ] Factual misinformation spreading rapidly

[ ] Direct question from journalist

[ ] Affected party seeking help

[ ] Influential account spreading false info

Medium priority (respond thoughtfully)

[ ] General negative sentiment

[ ] Questions about our response

[ ] Comparisons to competitors' handling

Low priority / Do not engage

[ ] Obvious trolling

[ ] Bad faith actors

[ ] Pile-on with no new claims

[ ] Emotional venting (let it pass)

Never respond

[ ] While angry

[ ] With unverified information

[ ] In a way that escalates conflict

[ ] By deleting legitimate criticism Internal crisis coordination Communication chain from dataclasses import dataclass from typing import List , Optional from datetime import datetime @dataclass class CrisisTeamMember : name : str role : str phone : str email : str backup : Optional [ 'CrisisTeamMember' ] = None @dataclass class CrisisLog : """Maintain record of all crisis decisions.""" entries : List [ dict ] = None def post_init ( self ) : self . entries = self . entries or [ ] def log ( self , action : str , decision_maker : str , rationale : str , outcome : str = "pending" ) : self . entries . append ( { 'timestamp' : datetime . now ( ) . isoformat ( ) , 'action' : action , 'decision_maker' : decision_maker , 'rationale' : rationale , 'outcome' : outcome } ) def export_for_postmortem ( self ) -

str : """Generate timeline for after-action review.""" lines = [ "# Crisis Response Timeline\n" ] for entry in self . entries : lines . append ( f"** { entry [ 'timestamp' ] } ** - { entry [ 'action' ] } \n" f"- Decision by: { entry [ 'decision_maker' ] } \n" f"- Rationale: { entry [ 'rationale' ] } \n" f"- Outcome: { entry [ 'outcome' ] } \n" ) return '\n' . join ( lines ) Status update template For keeping stakeholders informed:

Crisis status update #[X]

As of

[timestamp]
**
Next update
**: [scheduled time]

Current situation [2-3 sentence summary of where things stand]

What we know

[Confirmed fact 1]

[Confirmed fact 2]

What we're working on

[Action item 1] - [owner]

[Action item 2] - [owner]

Key decisions made

[Decision] - [rationale]

Immediate next steps 1. [Next action] 2. [Next action]

Resources needed

[Resource/support needed]

**
Contact
**: [Crisis lead name and number] Post-crisis review After-action checklist

Post-crisis review template

Timeline reconstruction

When did we first learn of the crisis?

When did we first respond publicly?

Key decision points and timing

What went well

[Specific success 1]

[Specific success 2]

What could improve

[Gap or failure 1] → [Recommended fix]

[Gap or failure 2] → [Recommended fix]

Process questions

Did escalation work as intended?

Were the right people involved?

Did we have accurate information when needed?

Was external communication timely and accurate?

Specific improvements

[ ] Update crisis protocol to address [gap]

[ ] Train team on [identified weakness]

[ ] Add [resource/tool] for future incidents

Documentation

All communications archived: [ ] Yes

Decision log complete: [ ] Yes

Media coverage compiled: [ ] Yes Misinformation rapid response Counter-messaging framework

Misinformation response checklist

Before responding

[ ] Is this claim spreading significantly?

[ ] Will our response reach the affected audience?

[ ] Could responding amplify the false claim?

The response formula 1. ** Lead with truth ** (don't repeat the myth first) 2. ** Be specific ** about what's accurate 3. ** Explain briefly ** why the false claim is wrong 4. ** Provide source ** for accurate information

Example structure GOOD: "The event starts at 7pm at City Hall. Some posts incorrectly listed the time as 5pm." BAD: "Some people are saying the event is at 5pm. That's wrong. It's actually at 7pm." (Repeating the myth first reinforces it) Journalist safety during crisis

安装