Petru Constantin is the founder of DeviDevs and designed the multi-agent platform the company runs on, with guardrails enforced in code. Code examples are written against the Python 3.12 and DORA (Regulation (EU) 2022/2554) with Delegated Regulations (EU) 2024/1772 and (EU) 2025/301 documentation.
DORA Compliance for Software Development: Digital Operational Resilience Act Guide
The Digital Operational Resilience Act (DORA) establishes uniform requirements for ICT risk management in the EU financial sector. This guide covers implementing DORA compliance for software development teams.
DORA Requirements Overview
Core Pillars
| Pillar | Description | Key Requirements | |--------|-------------|------------------| | ICT Risk Management | Comprehensive risk framework | Risk identification, protection, detection, response, recovery | | Incident Reporting | Standardized incident classification | Major incidents reported within 24 hours | | Resilience Testing | Regular testing of ICT systems | Threat-led penetration testing for significant entities | | Third-Party Risk | ICT service provider management | Due diligence, contracts, exit strategies | | Information Sharing | Threat intelligence sharing | Voluntary participation in sharing arrangements |
ICT Risk Management Framework
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Set
from enum import Enum
import json
class RiskLevel(Enum):
CRITICAL = "critical"
HIGH = "high"
MEDIUM = "medium"
LOW = "low"
class RiskCategory(Enum):
AVAILABILITY = "availability"
INTEGRITY = "integrity"
CONFIDENTIALITY = "confidentiality"
CONTINUITY = "continuity"
class AssetType(Enum):
CRITICAL_FUNCTION = "critical_function"
SUPPORTING_SYSTEM = "supporting_system"
DATA_ASSET = "data_asset"
THIRD_PARTY_SERVICE = "third_party_service"
@dataclass
class ICTAsset:
id: str
name: str
asset_type: AssetType
description: str
owner: str
criticality: RiskLevel
dependencies: List[str] = field(default_factory=list)
third_party_providers: List[str] = field(default_factory=list)
recovery_time_objective: int = 0 # minutes
recovery_point_objective: int = 0 # minutes
@dataclass
class ICTRisk:
id: str
title: str
description: str
category: RiskCategory
affected_assets: List[str]
likelihood: int # 1-5
impact: int # 1-5
risk_level: RiskLevel
controls: List[str]
residual_risk: RiskLevel
owner: str
review_date: datetime
status: str = "open"
@dataclass
class Control:
id: str
name: str
description: str
control_type: str # preventive, detective, corrective
implementation_status: str
effectiveness: str # effective, partially_effective, ineffective
last_tested: Optional[datetime] = None
test_results: Optional[str] = None
class DORAICTRiskFramework:
def __init__(self):
self.assets: Dict[str, ICTAsset] = {}
self.risks: Dict[str, ICTRisk] = {}
self.controls: Dict[str, Control] = {}
self.risk_appetite: Dict[RiskCategory, RiskLevel] = {}
def register_asset(self, asset: ICTAsset) -> str:
"""Register an ICT asset for risk management."""
self.assets[asset.id] = asset
# Auto-identify risks based on asset type and criticality
auto_risks = self._identify_asset_risks(asset)
for risk in auto_risks:
self.risks[risk.id] = risk
return asset.id
def _identify_asset_risks(self, asset: ICTAsset) -> List[ICTRisk]:
"""Automatically identify risks for an asset."""
risks = []
# Availability risks
if asset.criticality in [RiskLevel.CRITICAL, RiskLevel.HIGH]:
risks.append(ICTRisk(
id=f"RISK-{asset.id}-AVAIL",
title=f"Service unavailability for {asset.name}",
description=f"Risk of {asset.name} becoming unavailable",
category=RiskCategory.AVAILABILITY,
affected_assets=[asset.id],
likelihood=3,
impact=5 if asset.criticality == RiskLevel.CRITICAL else 4,
risk_level=RiskLevel.HIGH if asset.criticality == RiskLevel.CRITICAL else RiskLevel.MEDIUM,
controls=[],
residual_risk=RiskLevel.MEDIUM,
owner=asset.owner,
review_date=datetime.utcnow() + timedelta(days=90)
))
# Third-party risks
if asset.third_party_providers:
risks.append(ICTRisk(
id=f"RISK-{asset.id}-3P",
title=f"Third-party dependency risk for {asset.name}",
description=f"Risk from third-party provider failure affecting {asset.name}",
category=RiskCategory.CONTINUITY,
affected_assets=[asset.id],
likelihood=2,
impact=4,
risk_level=RiskLevel.MEDIUM,
controls=[],
residual_risk=RiskLevel.LOW,
owner=asset.owner,
review_date=datetime.utcnow() + timedelta(days=90)
))
# Data integrity risks
if asset.asset_type == AssetType.DATA_ASSET:
risks.append(ICTRisk(
id=f"RISK-{asset.id}-INTEG",
title=f"Data integrity risk for {asset.name}",
description=f"Risk of data corruption or unauthorized modification",
category=RiskCategory.INTEGRITY,
affected_assets=[asset.id],
likelihood=2,
impact=4,
risk_level=RiskLevel.MEDIUM,
controls=[],
residual_risk=RiskLevel.LOW,
owner=asset.owner,
review_date=datetime.utcnow() + timedelta(days=90)
))
return risks
def assess_risk(self, risk_id: str) -> Dict:
"""Assess a specific risk."""
risk = self.risks.get(risk_id)
if not risk:
raise ValueError(f"Risk {risk_id} not found")
# Calculate inherent risk score
inherent_score = risk.likelihood * risk.impact
# Get control effectiveness
control_effectiveness = self._calculate_control_effectiveness(risk.controls)
# Calculate residual risk
residual_score = inherent_score * (1 - control_effectiveness)
return {
"risk_id": risk_id,
"inherent_risk": {
"likelihood": risk.likelihood,
"impact": risk.impact,
"score": inherent_score,
"level": self._score_to_level(inherent_score)
},
"controls": {
"count": len(risk.controls),
"effectiveness": control_effectiveness
},
"residual_risk": {
"score": residual_score,
"level": self._score_to_level(residual_score)
},
"within_appetite": self._check_risk_appetite(risk.category, residual_score)
}
def _calculate_control_effectiveness(self, control_ids: List[str]) -> float:
"""Calculate aggregate control effectiveness."""
if not control_ids:
return 0.0
effectiveness_scores = {
"effective": 0.8,
"partially_effective": 0.4,
"ineffective": 0.0
}
total = 0
for control_id in control_ids:
control = self.controls.get(control_id)
if control:
total += effectiveness_scores.get(control.effectiveness, 0)
return total / len(control_ids) if control_ids else 0
def _score_to_level(self, score: float) -> RiskLevel:
"""Convert numeric score to risk level."""
if score >= 20:
return RiskLevel.CRITICAL
elif score >= 12:
return RiskLevel.HIGH
elif score >= 6:
return RiskLevel.MEDIUM
return RiskLevel.LOW
def _check_risk_appetite(self, category: RiskCategory, score: float) -> bool:
"""Check if risk is within appetite."""
appetite_level = self.risk_appetite.get(category, RiskLevel.MEDIUM)
risk_level = self._score_to_level(score)
level_order = [RiskLevel.LOW, RiskLevel.MEDIUM, RiskLevel.HIGH, RiskLevel.CRITICAL]
return level_order.index(risk_level) <= level_order.index(appetite_level)
def generate_risk_report(self) -> Dict:
"""Generate comprehensive risk report for DORA compliance."""
report = {
"generated_at": datetime.utcnow().isoformat(),
"summary": {
"total_assets": len(self.assets),
"total_risks": len(self.risks),
"total_controls": len(self.controls),
"risks_by_level": {},
"risks_by_category": {}
},
"critical_risks": [],
"control_gaps": [],
"third_party_dependencies": [],
"recommendations": []
}
# Aggregate risks
for risk in self.risks.values():
level = risk.risk_level.value
category = risk.category.value
report["summary"]["risks_by_level"][level] = \
report["summary"]["risks_by_level"].get(level, 0) + 1
report["summary"]["risks_by_category"][category] = \
report["summary"]["risks_by_category"].get(category, 0) + 1
# Flag critical risks
if risk.risk_level == RiskLevel.CRITICAL:
report["critical_risks"].append({
"id": risk.id,
"title": risk.title,
"category": category,
"owner": risk.owner
})
# Identify control gaps
if not risk.controls:
report["control_gaps"].append({
"risk_id": risk.id,
"risk_title": risk.title,
"recommendation": "Implement controls for this risk"
})
# Document third-party dependencies
for asset in self.assets.values():
if asset.third_party_providers:
report["third_party_dependencies"].append({
"asset_id": asset.id,
"asset_name": asset.name,
"providers": asset.third_party_providers,
"criticality": asset.criticality.value
})
return reportICT Incident Reporting
import json
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
from enum import Enum
from typing import Dict, List, Optional
class Criterion(Enum):
# Classification criteria from Commission Delegated Regulation (EU) 2024/1772.
# Whether a materiality threshold is met is assessed against that RTS;
# the thresholds are deliberately not hard-coded here.
CLIENTS_COUNTERPARTS_TRANSACTIONS = "clients_counterparts_transactions"
REPUTATIONAL_IMPACT = "reputational_impact"
DURATION_AND_DOWNTIME = "duration_and_service_downtime"
GEOGRAPHICAL_SPREAD = "geographical_spread"
DATA_LOSSES = "data_losses"
ECONOMIC_IMPACT = "economic_impact"
@dataclass
class DORAIncident:
id: str
title: str
detected_at: datetime
affects_critical_services: bool
malicious_access_with_possible_data_loss: bool = False
thresholds_met: List[Criterion] = field(default_factory=list)
classified_major_at: Optional[datetime] = None
deadlines: Dict[str, datetime] = field(default_factory=dict)
def is_major(incident: DORAIncident) -> bool:
"""Structure of Art. 8(1) RTS 2024/1772: critical services affected, plus
either malicious unauthorised access that may result in data losses, or the
materiality thresholds of two or more other criteria."""
if not incident.affects_critical_services:
return False
return (incident.malicious_access_with_possible_data_loss
or len(set(incident.thresholds_met)) >= 2)
def set_initial_deadline(incident: DORAIncident, classified_at: datetime) -> None:
# RTS 2025/301: initial notification within 4 hours of classification
# and no later than 24 hours after detection.
incident.classified_major_at = classified_at
initial = min(classified_at + timedelta(hours=4),
incident.detected_at + timedelta(hours=24))
if initial < classified_at:
# Classified late: check Art. 5 of RTS 2025/301 for this case.
initial = classified_at + timedelta(hours=4)
incident.deadlines["initial"] = initial
def on_initial_submitted(incident: DORAIncident, submitted_at: datetime) -> None:
# Intermediate report: within 72 hours of the initial notification.
incident.deadlines["intermediate"] = submitted_at + timedelta(hours=72)
def on_intermediate_submitted(incident: DORAIncident, submitted_at: datetime) -> None:
# Final report: no later than one month after the (latest updated)
# intermediate report. 28 days is never later than one calendar month.
incident.deadlines["final"] = submitted_at + timedelta(days=28)
def internal_alert(incident: DORAIncident) -> str:
"""Payload for your paging/alerting system. Report content and templates
are set by RTS 2025/301 and ITS 2025/302; submit through the channel your
competent authority defines."""
return json.dumps({
"type": "DORA_MAJOR_INCIDENT",
"incident_id": incident.id,
"title": incident.title,
"detected_at": incident.detected_at.isoformat(),
"deadlines": {k: v.isoformat() for k, v in incident.deadlines.items()},
"generated_at": datetime.now(timezone.utc).isoformat(),
})Digital Resilience Testing
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import List, Optional
TEST_TYPES = {
"vulnerability_assessment": "ICT systems and applications supporting critical or important functions",
"scenario_based_test": "e.g. data centre loss, ransomware, outage of a critical ICT provider",
# Art. 26 DORA: advanced testing, only for entities required to perform it.
"tlpt": ("several or all critical or important functions, on live production "
"systems; at least every 3 years unless the competent authority adjusts it"),
}
@dataclass
class TestRun:
test_type: str
scope: str
started_at: datetime
findings: List[dict] = field(default_factory=list)
passed: Optional[bool] = None # set from real results, never assumed
class DORAResilienceTesting:
def __init__(self):
self.runs: List[TestRun] = []
def plan(self, test_type: str, scope: Optional[str] = None) -> TestRun:
if test_type not in TEST_TYPES:
raise ValueError(f"Unknown test type: {test_type}")
run = TestRun(test_type, scope or TEST_TYPES[test_type],
datetime.now(timezone.utc))
self.runs.append(run)
return run
def record_result(self, run: TestRun, findings: List[dict]) -> None:
run.findings = findings
run.passed = not any(f.get("severity") in {"critical", "high"} for f in findings)
def open_findings(self) -> List[dict]:
"""Findings still to remediate. Having run tests is not the same as
being compliant: what matters is that findings get fixed."""
return [f for r in self.runs for f in r.findings if not f.get("remediated")]Third-Party Risk Management
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Dict, List, Optional
# RiskLevel is the enum defined in the ICT risk management block above.
@dataclass
class ThirdPartyProvider:
id: str
name: str
service_type: str
criticality: RiskLevel
contract_start: datetime
contract_end: datetime
services_provided: List[str]
data_access: bool
location: str
subcontractors: List[str] = field(default_factory=list)
last_assessment: Optional[datetime] = None
risk_rating: Optional[RiskLevel] = None
class DORAThirdPartyRiskManager:
def __init__(self):
self.providers: Dict[str, ThirdPartyProvider] = {}
self.assessments: Dict[str, List[Dict]] = {}
self.contracts: Dict[str, Dict] = {}
def register_provider(self, provider: ThirdPartyProvider) -> str:
"""Register a third-party ICT service provider."""
self.providers[provider.id] = provider
# Check if critical provider requires additional controls
if provider.criticality == RiskLevel.CRITICAL:
self._flag_critical_provider(provider)
return provider.id
def _flag_critical_provider(self, provider: ThirdPartyProvider):
"""Flag critical provider for enhanced monitoring."""
print(f"ALERT: Critical third-party provider registered: {provider.name}")
# Would trigger enhanced due diligence workflow
def perform_due_diligence(self, provider_id: str) -> Dict:
"""Perform DORA-required due diligence on provider."""
provider = self.providers.get(provider_id)
if not provider:
raise ValueError(f"Provider {provider_id} not found")
assessment = {
"provider_id": provider_id,
"assessment_date": datetime.now(timezone.utc).isoformat(),
"assessment_type": "due_diligence",
"areas_assessed": [],
"findings": [],
"risk_rating": None,
"recommendations": []
}
# DORA due diligence requirements
due_diligence_areas = [
{
"area": "financial_stability",
"checks": ["financial_statements", "credit_rating", "insurance_coverage"]
},
{
"area": "security_controls",
"checks": ["certifications", "security_audit_reports", "incident_history"]
},
{
"area": "business_continuity",
"checks": ["bcp_documentation", "dr_capabilities", "rto_rpo_guarantees"]
},
{
"area": "compliance",
"checks": ["regulatory_compliance", "data_protection", "subcontractor_oversight"]
},
{
"area": "exit_strategy",
"checks": ["data_portability", "transition_support", "termination_procedures"]
}
]
for area in due_diligence_areas:
area_result = self._assess_area(provider, area)
assessment["areas_assessed"].append(area_result)
if not area_result["satisfactory"]:
assessment["findings"].append({
"area": area["area"],
"issue": area_result["issues"],
"severity": "high" if provider.criticality == RiskLevel.CRITICAL else "medium"
})
# Calculate overall risk rating
assessment["risk_rating"] = self._calculate_provider_risk(assessment)
# Update provider record
provider.last_assessment = datetime.now(timezone.utc)
provider.risk_rating = RiskLevel(assessment["risk_rating"])
# Store assessment
if provider_id not in self.assessments:
self.assessments[provider_id] = []
self.assessments[provider_id].append(assessment)
return assessment
def _assess_area(self, provider: ThirdPartyProvider, area: Dict) -> Dict:
"""Assess a specific due diligence area."""
# Simplified assessment - would include actual checks
return {
"area": area["area"],
"checks_performed": area["checks"],
"satisfactory": area.get("satisfactory"), # set from the real review; unreviewed counts as a finding
"issues": []
}
def _calculate_provider_risk(self, assessment: Dict) -> str:
"""Calculate overall provider risk rating."""
finding_count = len(assessment["findings"])
high_findings = len([f for f in assessment["findings"] if f["severity"] == "high"])
if high_findings > 2:
return "critical"
elif high_findings > 0 or finding_count > 3:
return "high"
elif finding_count > 0:
return "medium"
return "low"
def generate_register(self) -> Dict:
"""Generate third-party register for regulatory reporting."""
register = {
"generated_at": datetime.now(timezone.utc).isoformat(),
"total_providers": len(self.providers),
"critical_providers": len([p for p in self.providers.values() if p.criticality == RiskLevel.CRITICAL]),
"providers": []
}
for provider in self.providers.values():
provider_entry = {
"id": provider.id,
"name": provider.name,
"service_type": provider.service_type,
"criticality": provider.criticality.value,
"services": provider.services_provided,
"data_access": provider.data_access,
"location": provider.location,
"contract_end": provider.contract_end.isoformat(),
"last_assessment": provider.last_assessment.isoformat() if provider.last_assessment else None,
"risk_rating": provider.risk_rating.value if provider.risk_rating else "not_assessed",
"subcontractors": provider.subcontractors
}
register["providers"].append(provider_entry)
return registerBest Practices
DORA Implementation
- Start with asset inventory: Identify and classify all ICT assets
- Map dependencies: Document third-party and internal dependencies
- Implement continuous monitoring: Real-time risk and incident monitoring
- Regular testing: Conduct resilience tests per DORA requirements
Compliance Maintenance
- Maintain up-to-date risk registers
- Document all incidents with required detail
- Review third-party contracts for DORA compliance
- Report major incidents within required timeframes
DORA compliance requires a comprehensive approach to digital operational resilience that spans risk management, incident handling, testing, and third-party oversight.
Official references
- Joint Technical Standards on major incident reporting (EBA)
- DORA Incident Reporting - Operational Instructions (ESAs, 16 September 2026)
- DORA Incident Reporting - Operational Instructions (ESAs), final report time limit
- Digital Operational Resilience Act (DORA) - EIOPA
- datetime - Basic date and time types (Python documentation)
Related on this site: CCPA Technical Compliance: Implementation Guide, GDPR Compliance for AI Systems: Tech Implementation, NIS2 and AI Act: Double Compliance for Romanian Companies. More articles in the Compliance category, and the engineering work behind them is on the services page.
Need an AI system built and running in production, with the scope agreed in writing and a delivery guarantee? See how a DeviDevs Sprint works →