Compliance

DORA Compliance for Software Development Teams

Nicu Constantin
••11 min read
#DORA#compliance#financial services#ICT risk#resilience

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 report

ICT 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 register

Best Practices

DORA Implementation

  1. Start with asset inventory: Identify and classify all ICT assets
  2. Map dependencies: Document third-party and internal dependencies
  3. Implement continuous monitoring: Real-time risk and incident monitoring
  4. 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

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 →

Want AI agents and automations your business can actually run on?

We ship production AI in fixed two-week sprints, then secure them. Book a 30-minute call to scope yours.

Book a Call

Before you book, you can see what we build, how a sprint works, how our pricing works, what we have already built, or write to us directly.

Weekly AI Agents, Automation & Security Digest

How we build AI agents and automations with Claude Code, plus practical AI security, integrations, and platform notes, delivered weekly.

No spam. Unsubscribe anytime.