diff --git a/README.md b/README.md
index 12be925..5cfa560 100644
--- a/README.md
+++ b/README.md
@@ -409,6 +409,18 @@ fn hello_returns_input() {
 - `curl not found` while funding
   - Install curl or fund the account manually using the friendbot URL
 
+### Windows: linker or "export ordinal too large"
+
+On Windows, `cargo test` may fail with **`link.exe` not found** (MSVC) or **`export ordinal too large: 79994`** (MinGW). The contract has many exports, which can exceed MinGW’s DLL limit.
+
+- **Verify the contract (WASM only, no tests):**
+  ```powershell
+  .\scripts\check-wasm.ps1
+  ```
+  Or: `cargo build -p teachlink-contract --target wasm32-unknown-unknown`
+- **Run full tests:** Install [Visual Studio Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/) with "Desktop development with C++", then use the default (MSVC) toolchain and run `cargo test -p teachlink-contract`.
+- **Otherwise:** Rely on CI (GitHub Actions) for `cargo test`; the WASM build is what gets deployed.
+
 ## License
 
 This project is licensed under the MIT License. See `LICENSE` for details.
diff --git a/contracts/teachlink/src/backup.rs b/contracts/teachlink/src/backup.rs
new file mode 100644
index 0000000..ffae369
--- /dev/null
+++ b/contracts/teachlink/src/backup.rs
@@ -0,0 +1,281 @@
+//! Backup and Disaster Recovery Module
+//!
+//! Provides backup scheduling, integrity verification, recovery recording,
+//! and audit trails for compliance. Off-chain systems use events to replicate
+//! data; this module records manifests, verification, and RTO recovery metrics.
+
+use crate::audit::AuditManager;
+use crate::errors::BridgeError;
+use crate::events::{BackupCreatedEvent, BackupVerifiedEvent, RecoveryExecutedEvent};
+use crate::storage::{
+    BACKUP_COUNTER, BACKUP_MANIFESTS, BACKUP_SCHEDULES, BACKUP_SCHED_CNT, RECOVERY_CNT,
+    RECOVERY_RECORDS,
+};
+use crate::types::{BackupManifest, BackupSchedule, OperationType, RecoveryRecord, RtoTier};
+use soroban_sdk::{Address, Bytes, Env, Map, Vec};
+
+/// Backup and disaster recovery manager
+pub struct BackupManager;
+
+impl BackupManager {
+    /// Create a backup manifest (authorized caller). Integrity hash is supplied by off-chain.
+    pub fn create_backup(
+        env: &Env,
+        creator: Address,
+        integrity_hash: Bytes,
+        rto_tier: RtoTier,
+        encryption_ref: u64,
+    ) -> Result<u64, BridgeError> {
+        creator.require_auth();
+
+        let mut counter: u64 = env
+            .storage()
+            .instance()
+            .get(&BACKUP_COUNTER)
+            .unwrap_or(0u64);
+        counter += 1;
+
+        let manifest = BackupManifest {
+            backup_id: counter,
+            created_at: env.ledger().timestamp(),
+            created_by: creator.clone(),
+            integrity_hash: integrity_hash.clone(),
+            rto_tier: rto_tier.clone(),
+            encryption_ref,
+        };
+
+        let mut manifests: Map<u64, BackupManifest> = env
+            .storage()
+            .instance()
+            .get(&BACKUP_MANIFESTS)
+            .unwrap_or_else(|| Map::new(env));
+        manifests.set(counter, manifest);
+        env.storage().instance().set(&BACKUP_MANIFESTS, &manifests);
+        env.storage().instance().set(&BACKUP_COUNTER, &counter);
+
+        BackupCreatedEvent {
+            backup_id: counter,
+            created_by: creator.clone(),
+            integrity_hash,
+            rto_tier: rto_tier.clone(),
+            created_at: env.ledger().timestamp(),
+        }
+        .publish(env);
+
+        let details = Bytes::from_slice(env, &counter.to_be_bytes());
+        AuditManager::create_audit_record(
+            env,
+            OperationType::BackupCreated,
+            creator,
+            details,
+            Bytes::new(env),
+        )?;
+
+        Ok(counter)
+    }
+
+    /// Get backup manifest by id
+    pub fn get_backup_manifest(env: &Env, backup_id: u64) -> Option<BackupManifest> {
+        let manifests: Map<u64, BackupManifest> = env
+            .storage()
+            .instance()
+            .get(&BACKUP_MANIFESTS)
+            .unwrap_or_else(|| Map::new(env));
+        manifests.get(backup_id)
+    }
+
+    /// Verify backup integrity (compare expected hash to stored). Emit event and audit.
+    pub fn verify_backup(
+        env: &Env,
+        backup_id: u64,
+        verifier: Address,
+        expected_hash: Bytes,
+    ) -> Result<bool, BridgeError> {
+        verifier.require_auth();
+
+        let manifest =
+            Self::get_backup_manifest(env, backup_id).ok_or(BridgeError::InvalidInput)?;
+        let valid = manifest.integrity_hash == expected_hash;
+
+        BackupVerifiedEvent {
+            backup_id,
+            verified_by: verifier.clone(),
+            verified_at: env.ledger().timestamp(),
+            valid,
+        }
+        .publish(env);
+
+        let details = Bytes::from_slice(env, &[if valid { 1u8 } else { 0u8 }]);
+        AuditManager::create_audit_record(
+            env,
+            OperationType::BackupVerified,
+            verifier,
+            details,
+            Bytes::new(env),
+        )?;
+
+        Ok(valid)
+    }
+
+    /// Schedule automated backup (owner auth)
+    pub fn schedule_backup(
+        env: &Env,
+        owner: Address,
+        next_run_at: u64,
+        interval_seconds: u64,
+        rto_tier: RtoTier,
+    ) -> Result<u64, BridgeError> {
+        owner.require_auth();
+
+        let mut counter: u64 = env
+            .storage()
+            .instance()
+            .get(&BACKUP_SCHED_CNT)
+            .unwrap_or(0u64);
+        counter += 1;
+
+        let schedule = BackupSchedule {
+            schedule_id: counter,
+            owner: owner.clone(),
+            next_run_at,
+            interval_seconds,
+            rto_tier: rto_tier.clone(),
+            enabled: true,
+            created_at: env.ledger().timestamp(),
+        };
+
+        let mut schedules: Map<u64, BackupSchedule> = env
+            .storage()
+            .instance()
+            .get(&BACKUP_SCHEDULES)
+            .unwrap_or_else(|| Map::new(env));
+        schedules.set(counter, schedule);
+        env.storage().instance().set(&BACKUP_SCHEDULES, &schedules);
+        env.storage().instance().set(&BACKUP_SCHED_CNT, &counter);
+
+        Ok(counter)
+    }
+
+    /// Get scheduled backups for an owner
+    pub fn get_scheduled_backups(env: &Env, owner: Address) -> Vec<BackupSchedule> {
+        let schedules: Map<u64, BackupSchedule> = env
+            .storage()
+            .instance()
+            .get(&BACKUP_SCHEDULES)
+            .unwrap_or_else(|| Map::new(env));
+
+        let mut result = Vec::new(env);
+        for (_id, s) in schedules.iter() {
+            if s.owner == owner {
+                result.push_back(s);
+            }
+        }
+        result
+    }
+
+    /// Record a recovery execution (RTO tracking and audit trail)
+    pub fn record_recovery(
+        env: &Env,
+        backup_id: u64,
+        executed_by: Address,
+        recovery_duration_secs: u64,
+        success: bool,
+    ) -> Result<u64, BridgeError> {
+        executed_by.require_auth();
+
+        if Self::get_backup_manifest(env, backup_id).is_none() {
+            return Err(BridgeError::InvalidInput);
+        }
+
+        let mut counter: u64 = env.storage().instance().get(&RECOVERY_CNT).unwrap_or(0u64);
+        counter += 1;
+
+        let record = RecoveryRecord {
+            recovery_id: counter,
+            backup_id,
+            executed_at: env.ledger().timestamp(),
+            executed_by: executed_by.clone(),
+            recovery_duration_secs,
+            success,
+        };
+
+        let mut records: Map<u64, RecoveryRecord> = env
+            .storage()
+            .instance()
+            .get(&RECOVERY_RECORDS)
+            .unwrap_or_else(|| Map::new(env));
+        records.set(counter, record);
+        env.storage().instance().set(&RECOVERY_RECORDS, &records);
+        env.storage().instance().set(&RECOVERY_CNT, &counter);
+
+        RecoveryExecutedEvent {
+            recovery_id: counter,
+            backup_id,
+            executed_by: executed_by.clone(),
+            recovery_duration_secs,
+            success,
+        }
+        .publish(env);
+
+        let details = Bytes::from_slice(env, &recovery_duration_secs.to_be_bytes());
+        AuditManager::create_audit_record(
+            env,
+            OperationType::RecoveryExecuted,
+            executed_by,
+            details,
+            Bytes::new(env),
+        )?;
+
+        Ok(counter)
+    }
+
+    /// Get recovery records (for audit trail and RTO reporting)
+    pub fn get_recovery_records(env: &Env, limit: u32) -> Vec<RecoveryRecord> {
+        let counter: u64 = env.storage().instance().get(&RECOVERY_CNT).unwrap_or(0u64);
+        let records: Map<u64, RecoveryRecord> = env
+            .storage()
+            .instance()
+            .get(&RECOVERY_RECORDS)
+            .unwrap_or_else(|| Map::new(env));
+
+        let mut result = Vec::new(env);
+        let start = if counter > limit as u64 {
+            counter - limit as u64
+        } else {
+            1
+        };
+        for id in start..=counter {
+            if let Some(r) = records.get(id) {
+                result.push_back(r);
+            }
+        }
+        result
+    }
+
+    /// Get recent backup manifests (for monitoring and compliance)
+    pub fn get_recent_backups(env: &Env, limit: u32) -> Vec<BackupManifest> {
+        let counter: u64 = env
+            .storage()
+            .instance()
+            .get(&BACKUP_COUNTER)
+            .unwrap_or(0u64);
+        let manifests: Map<u64, BackupManifest> = env
+            .storage()
+            .instance()
+            .get(&BACKUP_MANIFESTS)
+            .unwrap_or_else(|| Map::new(env));
+
+        let mut result = Vec::new(env);
+        let start = if counter > limit as u64 {
+            counter - limit as u64
+        } else {
+            1
+        };
+        for id in start..=counter {
+            if let Some(m) = manifests.get(id) {
+                result.push_back(m);
+            }
+        }
+        result
+    }
+}
diff --git a/contracts/teachlink/src/events.rs b/contracts/teachlink/src/events.rs
index c482699..3e82613 100644
--- a/contracts/teachlink/src/events.rs
+++ b/contracts/teachlink/src/events.rs
@@ -454,3 +454,34 @@ pub struct AlertTriggeredEvent {
     pub threshold: i128,
     pub triggered_at: u64,
 }
+
+// ================= Backup and Disaster Recovery Events =================
+
+#[contractevent]
+#[derive(Clone, Debug)]
+pub struct BackupCreatedEvent {
+    pub backup_id: u64,
+    pub created_by: Address,
+    pub integrity_hash: Bytes,
+    pub rto_tier: crate::types::RtoTier,
+    pub created_at: u64,
+}
+
+#[contractevent]
+#[derive(Clone, Debug)]
+pub struct BackupVerifiedEvent {
+    pub backup_id: u64,
+    pub verified_by: Address,
+    pub verified_at: u64,
+    pub valid: bool,
+}
+
+#[contractevent]
+#[derive(Clone, Debug)]
+pub struct RecoveryExecutedEvent {
+    pub recovery_id: u64,
+    pub backup_id: u64,
+    pub executed_by: Address,
+    pub recovery_duration_secs: u64,
+    pub success: bool,
+}
diff --git a/contracts/teachlink/src/lib.rs b/contracts/teachlink/src/lib.rs
index a75afea..e2b65ce 100644
--- a/contracts/teachlink/src/lib.rs
+++ b/contracts/teachlink/src/lib.rs
@@ -41,6 +41,7 @@
 //! | [`atomic_swap`] | Cross-chain atomic swaps |
 //! | [`analytics`] | Bridge monitoring and analytics |
 //! | [`reporting`] | Advanced analytics, report templates, dashboards, and alerting |
+//! | [`backup`] | Backup scheduling, integrity verification, disaster recovery, and RTO audit |
 //! | [`rewards`] | Reward pool management and distribution |
 //! | [`escrow`] | Multi-signature escrow with dispute resolution |
 //! | [`tokenization`] | Educational content NFT minting and management |
@@ -107,6 +108,7 @@ mod multichain;
 mod notification;
 mod notification_events_basic;
 // mod notification_tests; // TODO: Re-enable when testutils dependencies are resolved
+mod backup;
 mod notification_types;
 mod reporting;
 mod rewards;
@@ -120,17 +122,17 @@ pub mod validation;
 
 pub use errors::{BridgeError, EscrowError, RewardsError};
 pub use types::{
-    AlertConditionType, AlertRule, ArbitratorProfile, AtomicSwap, AuditRecord, BridgeMetrics,
-    BridgeProposal, BridgeTransaction, ChainConfig, ChainMetrics, ComplianceReport, ConsensusState,
-    ContentMetadata, ContentToken, ContentTokenParameters, CrossChainMessage, CrossChainPacket,
-    DashboardAnalytics, DisputeOutcome, EmergencyState, Escrow, EscrowMetrics, EscrowParameters,
-    EscrowStatus, LiquidityPool, MultiChainAsset, NotificationChannel, NotificationContent,
-    NotificationPreference, NotificationSchedule, NotificationTemplate, NotificationTracking,
-    OperationType, PacketStatus, ProposalStatus, ProvenanceRecord, ReportComment, ReportSchedule,
-    ReportSnapshot, ReportTemplate, ReportType, ReportUsage, RewardRate, RewardType,
-    SlashingReason, SlashingRecord, SwapStatus, TransferType, UserNotificationSettings,
-    UserReputation, UserReward, ValidatorInfo, ValidatorReward, ValidatorSignature,
-    VisualizationDataPoint,
+    AlertConditionType, AlertRule, ArbitratorProfile, AtomicSwap, AuditRecord, BackupManifest,
+    BackupSchedule, BridgeMetrics, BridgeProposal, BridgeTransaction, ChainConfig, ChainMetrics,
+    ComplianceReport, ConsensusState, ContentMetadata, ContentToken, ContentTokenParameters,
+    CrossChainMessage, CrossChainPacket, DashboardAnalytics, DisputeOutcome, EmergencyState,
+    Escrow, EscrowMetrics, EscrowParameters, EscrowStatus, LiquidityPool, MultiChainAsset,
+    NotificationChannel, NotificationContent, NotificationPreference, NotificationSchedule,
+    NotificationTemplate, NotificationTracking, OperationType, PacketStatus, ProposalStatus,
+    ProvenanceRecord, RecoveryRecord, ReportComment, ReportSchedule, ReportSnapshot,
+    ReportTemplate, ReportType, ReportUsage, RewardRate, RewardType, RtoTier, SlashingReason,
+    SlashingRecord, SwapStatus, TransferType, UserNotificationSettings, UserReputation, UserReward,
+    ValidatorInfo, ValidatorReward, ValidatorSignature, VisualizationDataPoint,
 };
 
 /// TeachLink main contract.
@@ -800,6 +802,77 @@ impl TeachLinkBridge {
         reporting::ReportingManager::get_recent_report_snapshots(&env, limit)
     }
 
+    // ========== Backup and Disaster Recovery Functions ==========
+
+    /// Create a backup manifest (integrity hash from off-chain)
+    pub fn create_backup(
+        env: Env,
+        creator: Address,
+        integrity_hash: Bytes,
+        rto_tier: RtoTier,
+        encryption_ref: u64,
+    ) -> Result<u64, BridgeError> {
+        backup::BackupManager::create_backup(&env, creator, integrity_hash, rto_tier, encryption_ref)
+    }
+
+    /// Get backup manifest by id
+    pub fn get_backup_manifest(env: Env, backup_id: u64) -> Option<BackupManifest> {
+        backup::BackupManager::get_backup_manifest(&env, backup_id)
+    }
+
+    /// Verify backup integrity
+    pub fn verify_backup(
+        env: Env,
+        backup_id: u64,
+        verifier: Address,
+        expected_hash: Bytes,
+    ) -> Result<bool, BridgeError> {
+        backup::BackupManager::verify_backup(&env, backup_id, verifier, expected_hash)
+    }
+
+    /// Schedule automated backup
+    pub fn schedule_backup(
+        env: Env,
+        owner: Address,
+        next_run_at: u64,
+        interval_seconds: u64,
+        rto_tier: RtoTier,
+    ) -> Result<u64, BridgeError> {
+        backup::BackupManager::schedule_backup(&env, owner, next_run_at, interval_seconds, rto_tier)
+    }
+
+    /// Get scheduled backups for an owner
+    pub fn get_scheduled_backups(env: Env, owner: Address) -> Vec<BackupSchedule> {
+        backup::BackupManager::get_scheduled_backups(&env, owner)
+    }
+
+    /// Record a recovery execution (RTO tracking and audit)
+    pub fn record_recovery(
+        env: Env,
+        backup_id: u64,
+        executed_by: Address,
+        recovery_duration_secs: u64,
+        success: bool,
+    ) -> Result<u64, BridgeError> {
+        backup::BackupManager::record_recovery(
+            &env,
+            backup_id,
+            executed_by,
+            recovery_duration_secs,
+            success,
+        )
+    }
+
+    /// Get recovery records for audit and RTO reporting
+    pub fn get_recovery_records(env: Env, limit: u32) -> Vec<RecoveryRecord> {
+        backup::BackupManager::get_recovery_records(&env, limit)
+    }
+
+    /// Get recent backup manifests
+    pub fn get_recent_backups(env: Env, limit: u32) -> Vec<BackupManifest> {
+        backup::BackupManager::get_recent_backups(&env, limit)
+    }
+
     // ========== Rewards Functions ==========
 
     /// Initialize the rewards system
diff --git a/contracts/teachlink/src/storage.rs b/contracts/teachlink/src/storage.rs
index d033040..bcd1ebd 100644
--- a/contracts/teachlink/src/storage.rs
+++ b/contracts/teachlink/src/storage.rs
@@ -116,3 +116,11 @@ pub const REPORT_COMMENT_COUNTER: Symbol = symbol_short!("rpt_cmtcn");
 pub const REPORT_COMMENTS: Symbol = symbol_short!("rpt_cmt");
 pub const ALERT_RULE_COUNTER: Symbol = symbol_short!("alrt_cnt");
 pub const ALERT_RULES: Symbol = symbol_short!("alrt_ruls");
+
+// Backup and Disaster Recovery Storage (symbol_short! max 9 chars)
+pub const BACKUP_COUNTER: Symbol = symbol_short!("bak_cnt");
+pub const BACKUP_MANIFESTS: Symbol = symbol_short!("bak_mnf");
+pub const BACKUP_SCHED_CNT: Symbol = symbol_short!("bak_scc");
+pub const BACKUP_SCHEDULES: Symbol = symbol_short!("bak_sch");
+pub const RECOVERY_CNT: Symbol = symbol_short!("rec_cnt");
+pub const RECOVERY_RECORDS: Symbol = symbol_short!("rec_rec");
diff --git a/contracts/teachlink/src/types.rs b/contracts/teachlink/src/types.rs
index 1dae1d6..1dfa96c 100644
--- a/contracts/teachlink/src/types.rs
+++ b/contracts/teachlink/src/types.rs
@@ -244,6 +244,9 @@ pub enum OperationType {
     EmergencyResume,
     FeeUpdate,
     ConfigUpdate,
+    BackupCreated,
+    BackupVerified,
+    RecoveryExecuted,
 }
 
 #[contracttype]
@@ -720,3 +723,54 @@ pub struct DashboardAnalytics {
     pub audit_record_count: u64,
     pub generated_at: u64,
 }
+
+// ========== Backup and Disaster Recovery Types ==========
+
+/// RTO tier for recovery time objective (seconds)
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum RtoTier {
+    Critical, // e.g. 300 (5 min)
+    High,     // e.g. 3600 (1 hr)
+    Standard, // e.g. 86400 (24 hr)
+}
+
+/// Backup manifest (metadata for integrity and audit)
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct BackupManifest {
+    pub backup_id: u64,
+    pub created_at: u64,
+    pub created_by: Address,
+    /// Integrity hash (e.g. hash of critical state snapshot)
+    pub integrity_hash: Bytes,
+    pub rto_tier: RtoTier,
+    /// Encryption/access: 0 = none, non-zero = key version or access policy id
+    pub encryption_ref: u64,
+}
+
+/// Scheduled backup config
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct BackupSchedule {
+    pub schedule_id: u64,
+    pub owner: Address,
+    pub next_run_at: u64,
+    pub interval_seconds: u64,
+    pub rto_tier: RtoTier,
+    pub enabled: bool,
+    pub created_at: u64,
+}
+
+/// Recovery record for audit trail and RTO tracking
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RecoveryRecord {
+    pub recovery_id: u64,
+    pub backup_id: u64,
+    pub executed_at: u64,
+    pub executed_by: Address,
+    /// Recovery duration in seconds (RTO measurement)
+    pub recovery_duration_secs: u64,
+    pub success: bool,
+}
diff --git a/contracts/teachlink/tests/test_backup_dr.rs b/contracts/teachlink/tests/test_backup_dr.rs
new file mode 100644
index 0000000..f6388bd
--- /dev/null
+++ b/contracts/teachlink/tests/test_backup_dr.rs
@@ -0,0 +1,34 @@
+#![cfg(test)]
+#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::needless_pass_by_value)]
+#![allow(clippy::unreadable_literal)]
+
+//! Tests for backup and disaster recovery system.
+//!
+//! When the contract impl is enabled, extend with:
+//! - create_backup, get_backup_manifest
+//! - verify_backup (valid / invalid hash)
+//! - schedule_backup, get_scheduled_backups
+//! - record_recovery, get_recovery_records
+//! - get_recent_backups
+
+use soroban_sdk::Env;
+
+use teachlink_contract::{RtoTier, TeachLinkBridge};
+
+#[test]
+fn test_contract_registers_with_backup_module() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let _ = env.register(TeachLinkBridge, ());
+    assert!(true);
+}
+
+#[test]
+fn test_rto_tier_variants() {
+    let _ = RtoTier::Critical;
+    let _ = RtoTier::High;
+    let _ = RtoTier::Standard;
+    assert!(true);
+}
diff --git a/indexer/src/app.module.ts b/indexer/src/app.module.ts
index 634aef7..f21e131 100644
--- a/indexer/src/app.module.ts
+++ b/indexer/src/app.module.ts
@@ -7,6 +7,7 @@ import { HorizonModule } from '@horizon/horizon.module';
 import { EventsModule } from '@events/events.module';
 import { IndexerModule } from '@indexer/indexer.module';
 import { ReportingModule } from './reporting/reporting.module';
+import { BackupModule } from './backup/backup.module';
 
 @Module({
   imports: [
@@ -20,6 +21,7 @@ import { ReportingModule } from './reporting/reporting.module';
     EventsModule,
     IndexerModule,
     ReportingModule,
+    BackupModule,
   ],
 })
 export class AppModule {}
diff --git a/indexer/src/backup/backup.controller.ts b/indexer/src/backup/backup.controller.ts
new file mode 100644
index 0000000..44d3a64
--- /dev/null
+++ b/indexer/src/backup/backup.controller.ts
@@ -0,0 +1,37 @@
+import { Controller, Get, Query, ParseIntPipe, DefaultValuePipe } from '@nestjs/common';
+import { BackupService } from './backup.service';
+import { RtoTier } from '@database/entities/backup-manifest.entity';
+
+/**
+ * API for backup and disaster recovery: audit trail, RTO reporting, compliance.
+ */
+@Controller('backup')
+export class BackupController {
+  constructor(private backupService: BackupService) {}
+
+  @Get('manifests')
+  async getManifests(
+    @Query('limit', new DefaultValuePipe(100), ParseIntPipe) limit?: number,
+    @Query('rtoTier') rtoTier?: RtoTier,
+  ) {
+    return this.backupService.getBackupManifests(limit, rtoTier);
+  }
+
+  @Get('recoveries')
+  async getRecoveries(@Query('limit', new DefaultValuePipe(100), ParseIntPipe) limit?: number) {
+    return this.backupService.getRecoveryRecords(limit);
+  }
+
+  @Get('rto-metrics')
+  async getRtoMetrics() {
+    return this.backupService.getRtoMetrics();
+  }
+
+  @Get('audit-trail')
+  async getAuditTrail(
+    @Query('since') since: string,
+    @Query('limit', new DefaultValuePipe(200), ParseIntPipe) limit?: number,
+  ) {
+    return this.backupService.getBackupAuditTrail(since || '0', limit);
+  }
+}
diff --git a/indexer/src/backup/backup.module.ts b/indexer/src/backup/backup.module.ts
new file mode 100644
index 0000000..81f9d65
--- /dev/null
+++ b/indexer/src/backup/backup.module.ts
@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { BackupManifestRecord, RecoveryRecordEntity } from '@database/entities';
+import { BackupService } from './backup.service';
+import { BackupController } from './backup.controller';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([BackupManifestRecord, RecoveryRecordEntity]),
+  ],
+  controllers: [BackupController],
+  providers: [BackupService],
+  exports: [BackupService],
+})
+export class BackupModule {}
diff --git a/indexer/src/backup/backup.service.ts b/indexer/src/backup/backup.service.ts
new file mode 100644
index 0000000..09218a9
--- /dev/null
+++ b/indexer/src/backup/backup.service.ts
@@ -0,0 +1,76 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { BackupManifestRecord, RecoveryRecordEntity } from '@database/entities';
+import { RtoTier } from '@database/entities/backup-manifest.entity';
+
+/**
+ * Backup and disaster recovery: audit trail, RTO reporting, and integrity monitoring.
+ */
+@Injectable()
+export class BackupService {
+  private readonly logger = new Logger(BackupService.name);
+
+  constructor(
+    @InjectRepository(BackupManifestRecord)
+    private backupManifestRepo: Repository<BackupManifestRecord>,
+    @InjectRepository(RecoveryRecordEntity)
+    private recoveryRecordRepo: Repository<RecoveryRecordEntity>,
+  ) {}
+
+  async getBackupManifests(limit = 100, rtoTier?: RtoTier): Promise<BackupManifestRecord[]> {
+    const qb = this.backupManifestRepo
+      .createQueryBuilder('b')
+      .orderBy('b.createdAt', 'DESC')
+      .take(limit);
+    if (rtoTier) qb.andWhere('b.rtoTier = :rtoTier', { rtoTier });
+    return qb.getMany();
+  }
+
+  async getRecoveryRecords(limit = 100): Promise<RecoveryRecordEntity[]> {
+    return this.recoveryRecordRepo.find({
+      take: limit,
+      order: { executedAt: 'DESC' },
+    });
+  }
+
+  /** RTO metrics: average recovery duration and success rate */
+  async getRtoMetrics(): Promise<{ avgDurationSecs: number; successCount: number; totalCount: number }> {
+    const records = await this.recoveryRecordRepo.find({ take: 500 });
+    const total = records.length;
+    const successCount = records.filter((r) => r.success).length;
+    const sumSecs = records.reduce((acc, r) => acc + Number(r.recoveryDurationSecs), 0);
+    return {
+      avgDurationSecs: total > 0 ? Math.round(sumSecs / total) : 0,
+      successCount,
+      totalCount: total,
+    };
+  }
+
+  /** Compliance: backup and recovery audit trail for a period */
+  async getBackupAuditTrail(since: string, limit = 200): Promise<{
+    backups: BackupManifestRecord[];
+    recoveries: RecoveryRecordEntity[];
+  }> {
+    const backups = await this.backupManifestRepo
+      .createQueryBuilder('b')
+      .where('b.createdAt >= :since', { since })
+      .orderBy('b.createdAt', 'DESC')
+      .take(limit)
+      .getMany();
+    const recoveries = await this.recoveryRecordRepo
+      .createQueryBuilder('r')
+      .where('r.executedAt >= :since', { since })
+      .orderBy('r.executedAt', 'DESC')
+      .take(limit)
+      .getMany();
+    return { backups, recoveries };
+  }
+
+  /** Automated backup check: run periodically; off-chain should call contract create_backup with integrity hash */
+  @Cron(CronExpression.EVERY_HOUR)
+  async runBackupCheck(): Promise<void> {
+    this.logger.log('Backup check: consider triggering create_backup for any scheduled backups (off-chain).');
+  }
+}
diff --git a/indexer/src/database/database.module.ts b/indexer/src/database/database.module.ts
index 5f79150..cecaf25 100644
--- a/indexer/src/database/database.module.ts
+++ b/indexer/src/database/database.module.ts
@@ -16,6 +16,8 @@ import {
   ReportUsage,
   AlertRule,
   AlertLog,
+  BackupManifestRecord,
+  RecoveryRecordEntity,
 } from './entities';
 
 @Module({
@@ -44,6 +46,8 @@ import {
           ReportUsage,
           AlertRule,
           AlertLog,
+          BackupManifestRecord,
+          RecoveryRecordEntity,
         ],
         synchronize: configService.get<boolean>('database.synchronize'),
         logging: configService.get<boolean>('database.logging'),
@@ -65,6 +69,8 @@ import {
       ReportUsage,
       AlertRule,
       AlertLog,
+      BackupManifestRecord,
+      RecoveryRecordEntity,
     ]),
   ],
   exports: [TypeOrmModule],
diff --git a/indexer/src/database/entities/backup-manifest.entity.ts b/indexer/src/database/entities/backup-manifest.entity.ts
new file mode 100644
index 0000000..1b50bb1
--- /dev/null
+++ b/indexer/src/database/entities/backup-manifest.entity.ts
@@ -0,0 +1,52 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  Index,
+  CreateDateColumn,
+} from 'typeorm';
+
+export enum RtoTier {
+  CRITICAL = 'critical',
+  HIGH = 'high',
+  STANDARD = 'standard',
+}
+
+/**
+ * Indexed backup manifest for disaster recovery audit and monitoring.
+ */
+@Entity('backup_manifests')
+@Index(['backupId'])
+@Index(['createdAt'])
+@Index(['createdBy'])
+export class BackupManifestRecord {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'bigint' })
+  backupId: string;
+
+  @Column({ type: 'bigint' })
+  createdAt: string;
+
+  @Column()
+  createdBy: string;
+
+  @Column({ type: 'text' })
+  integrityHash: string;
+
+  @Column({ type: 'enum', enum: RtoTier })
+  rtoTier: RtoTier;
+
+  @Column({ type: 'bigint', default: 0 })
+  encryptionRef: string;
+
+  @Column({ type: 'bigint' })
+  ledger: string;
+
+  @Column()
+  txHash: string;
+
+  @CreateDateColumn()
+  indexedAt: Date;
+}
diff --git a/indexer/src/database/entities/index.ts b/indexer/src/database/entities/index.ts
index 5d273bc..61fa373 100644
--- a/indexer/src/database/entities/index.ts
+++ b/indexer/src/database/entities/index.ts
@@ -12,3 +12,5 @@ export * from './dashboard-snapshot.entity';
 export * from './report-usage.entity';
 export * from './alert-rule.entity';
 export * from './alert-log.entity';
+export * from './backup-manifest.entity';
+export * from './recovery-record.entity';
diff --git a/indexer/src/database/entities/recovery-record.entity.ts b/indexer/src/database/entities/recovery-record.entity.ts
new file mode 100644
index 0000000..8fa6817
--- /dev/null
+++ b/indexer/src/database/entities/recovery-record.entity.ts
@@ -0,0 +1,46 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  Index,
+  CreateDateColumn,
+} from 'typeorm';
+
+/**
+ * Recovery execution record for RTO tracking and disaster recovery audit trail.
+ */
+@Entity('recovery_records')
+@Index(['recoveryId'])
+@Index(['backupId'])
+@Index(['executedAt'])
+export class RecoveryRecordEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'bigint' })
+  recoveryId: string;
+
+  @Column({ type: 'bigint' })
+  backupId: string;
+
+  @Column({ type: 'bigint' })
+  executedAt: string;
+
+  @Column()
+  executedBy: string;
+
+  @Column({ type: 'bigint' })
+  recoveryDurationSecs: string;
+
+  @Column({ type: 'boolean' })
+  success: boolean;
+
+  @Column({ type: 'bigint' })
+  ledger: string;
+
+  @Column()
+  txHash: string;
+
+  @CreateDateColumn()
+  indexedAt: Date;
+}
diff --git a/indexer/src/events/event-processor.service.ts b/indexer/src/events/event-processor.service.ts
index eefbf6e..ff513cb 100644
--- a/indexer/src/events/event-processor.service.ts
+++ b/indexer/src/events/event-processor.service.ts
@@ -16,7 +16,10 @@ import {
   Contribution,
   RewardPool,
   AlertLog,
+  BackupManifestRecord,
+  RecoveryRecordEntity,
 } from '@database/entities';
+import { RtoTier } from '@database/entities/backup-manifest.entity';
 import { ProcessedEvent } from '@horizon/horizon.service';
 import {
   BridgeEvent,
@@ -25,6 +28,7 @@ import {
   TokenizationEvent,
   ScoringEvent,
   ReportingEvent,
+  BackupEvent,
 } from './event-types';
 
 @Injectable()
@@ -52,6 +56,10 @@ export class EventProcessorService {
     private rewardPoolRepo: Repository<RewardPool>,
     @InjectRepository(AlertLog)
     private alertLogRepo: Repository<AlertLog>,
+    @InjectRepository(BackupManifestRecord)
+    private backupManifestRepo: Repository<BackupManifestRecord>,
+    @InjectRepository(RecoveryRecordEntity)
+    private recoveryRecordRepo: Repository<RecoveryRecordEntity>,
   ) {}
 
   async processEvent(event: ProcessedEvent): Promise<void> {
@@ -144,6 +152,17 @@ export class EventProcessorService {
           await this.handleAlertTriggeredEvent(event);
           break;
 
+        // Backup and DR Events
+        case 'BackupCreatedEvent':
+          await this.handleBackupCreatedEvent(event);
+          break;
+        case 'BackupVerifiedEvent':
+          await this.handleBackupVerifiedEvent(event);
+          break;
+        case 'RecoveryExecutedEvent':
+          await this.handleRecoveryExecutedEvent(event);
+          break;
+
         default:
           this.logger.warn(`Unknown event type: ${eventType}`);
       }
@@ -646,6 +665,45 @@ export class EventProcessorService {
     this.logger.log(`Indexed AlertTriggeredEvent rule_id=${data.rule_id}`);
   }
 
+  // Backup and DR Event Handlers
+  private async handleBackupCreatedEvent(event: ProcessedEvent): Promise<void> {
+    const data = event.data as { backup_id: string; created_by: string; integrity_hash: string; rto_tier: string; created_at: string };
+    const rtoTier = (data.rto_tier || 'standard').toLowerCase() as keyof typeof RtoTier;
+    const record = this.backupManifestRepo.create({
+      backupId: data.backup_id,
+      createdAt: data.created_at,
+      createdBy: data.created_by,
+      integrityHash: data.integrity_hash,
+      rtoTier: RtoTier[rtoTier] ?? RtoTier.STANDARD,
+      encryptionRef: '0',
+      ledger: event.ledger,
+      txHash: event.txHash,
+    });
+    await this.backupManifestRepo.save(record);
+    this.logger.log(`Indexed BackupCreatedEvent backup_id=${data.backup_id}`);
+  }
+
+  private async handleBackupVerifiedEvent(event: ProcessedEvent): Promise<void> {
+    const data = event.data as { backup_id: string; verified_by: string; verified_at: string; valid: boolean };
+    this.logger.log(`Indexed BackupVerifiedEvent backup_id=${data.backup_id} valid=${data.valid}`);
+  }
+
+  private async handleRecoveryExecutedEvent(event: ProcessedEvent): Promise<void> {
+    const data = event.data as { recovery_id: string; backup_id: string; executed_by: string; recovery_duration_secs: string; success: boolean };
+    const record = this.recoveryRecordRepo.create({
+      recoveryId: data.recovery_id,
+      backupId: data.backup_id,
+      executedAt: event.timestamp || String(Math.floor(Date.now() / 1000)),
+      executedBy: data.executed_by,
+      recoveryDurationSecs: data.recovery_duration_secs,
+      success: data.success,
+      ledger: event.ledger,
+      txHash: event.txHash,
+    });
+    await this.recoveryRecordRepo.save(record);
+    this.logger.log(`Indexed RecoveryExecutedEvent recovery_id=${data.recovery_id}`);
+  }
+
   private mapProvenanceEventType(eventType: string): ProvenanceEventType {
     switch (eventType.toLowerCase()) {
       case 'mint':
diff --git a/indexer/src/events/event-types/backup.events.ts b/indexer/src/events/event-types/backup.events.ts
new file mode 100644
index 0000000..74f92d7
--- /dev/null
+++ b/indexer/src/events/event-types/backup.events.ts
@@ -0,0 +1,27 @@
+export interface BackupCreatedEvent {
+  backup_id: string;
+  created_by: string;
+  integrity_hash: string;
+  rto_tier: string;
+  created_at: string;
+}
+
+export interface BackupVerifiedEvent {
+  backup_id: string;
+  verified_by: string;
+  verified_at: string;
+  valid: boolean;
+}
+
+export interface RecoveryExecutedEvent {
+  recovery_id: string;
+  backup_id: string;
+  executed_by: string;
+  recovery_duration_secs: string;
+  success: boolean;
+}
+
+export type BackupEvent =
+  | { type: 'BackupCreatedEvent'; data: BackupCreatedEvent }
+  | { type: 'BackupVerifiedEvent'; data: BackupVerifiedEvent }
+  | { type: 'RecoveryExecutedEvent'; data: RecoveryExecutedEvent };
diff --git a/indexer/src/events/event-types/index.ts b/indexer/src/events/event-types/index.ts
index 0d6beab..b895254 100644
--- a/indexer/src/events/event-types/index.ts
+++ b/indexer/src/events/event-types/index.ts
@@ -4,6 +4,7 @@ export * from './escrow.events';
 export * from './tokenization.events';
 export * from './scoring.events';
 export * from './reporting.events';
+export * from './backup.events';
 
 import { BridgeEvent } from './bridge.events';
 import { RewardEvent } from './reward.events';
@@ -11,6 +12,7 @@ import { EscrowEvent } from './escrow.events';
 import { TokenizationEvent } from './tokenization.events';
 import { ScoringEvent } from './scoring.events';
 import { ReportingEvent } from './reporting.events';
+import { BackupEvent } from './backup.events';
 
 export type ContractEvent =
   | BridgeEvent
@@ -18,4 +20,5 @@ export type ContractEvent =
   | EscrowEvent
   | TokenizationEvent
   | ScoringEvent
-  | ReportingEvent;
+  | ReportingEvent
+  | BackupEvent;
diff --git a/scripts/check-wasm.ps1 b/scripts/check-wasm.ps1
new file mode 100644
index 0000000..7605aed
--- /dev/null
+++ b/scripts/check-wasm.ps1
@@ -0,0 +1,15 @@
+# Verify the teachlink contract compiles to WASM (no host DLL).
+# Use this on Windows when you don't have Visual Studio Build Tools,
+# to avoid the MinGW "export ordinal too large" error when running cargo test.
+# Full tests run in CI (Linux) or with VS Build Tools installed.
+Set-Location $PSScriptRoot\..
+
+$target = "wasm32-unknown-unknown"
+Write-Host "[*] Building teachlink-contract for $target ..." -ForegroundColor Cyan
+cargo build -p teachlink-contract --target $target
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "[OK] WASM build succeeded. Contract is ready for deployment." -ForegroundColor Green
+} else {
+    Write-Host "[FAIL] Build failed." -ForegroundColor Red
+    exit 1
+}