diff --git a/backend/src/dal/index.js b/backend/src/dal/index.js
index fece83cd..18721b07 100644
--- a/backend/src/dal/index.js
+++ b/backend/src/dal/index.js
@@ -24,6 +24,7 @@ import { createSqliteFeatureFlagRepository } from './sqliteFeatureFlagRepository
 import { createSqliteIdempotencyRepository } from './sqliteIdempotencyRepository.js';
 import { createSqliteNotificationRepository } from './sqliteNotificationRepository.js';
 import { createSqliteNotificationPreferencesRepository } from './sqliteNotificationPreferencesRepository.js';
+import { createSqliteStatusRepository } from './sqliteStatusRepository.js';
 
 import { runPgMigrations } from './pg/migrate.js';
 import { createPgCampaignRepository } from './pg/pgCampaignRepository.js';
@@ -100,6 +101,7 @@ export async function createDal({
     idempotency: createSqliteIdempotencyRepository({ db }),
     notifications: createSqliteNotificationRepository({ db }),
     notificationPreferences: createSqliteNotificationPreferencesRepository({ db }),
+    status: createSqliteStatusRepository({ db }),
     db,
     pgPool,
   };
diff --git a/backend/src/dal/sqliteStatusRepository.js b/backend/src/dal/sqliteStatusRepository.js
new file mode 100644
index 00000000..66443db1
--- /dev/null
+++ b/backend/src/dal/sqliteStatusRepository.js
@@ -0,0 +1,212 @@
+export function createSqliteStatusRepository({ db }) {
+  return {
+    // Incidents
+    createIncident({ id, title, description, components, status, impact, createdAt, updatedAt }) {
+      const stmt = db.prepare(`
+        INSERT INTO status_incidents (id, title, description, components, status, impact, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(id, title, description, JSON.stringify(components), status, impact, createdAt, updatedAt);
+      return { id };
+    },
+
+    getIncident(id) {
+      const stmt = db.prepare(`
+        SELECT id, title, description, components, status, impact, created_at, updated_at
+        FROM status_incidents
+        WHERE id = ?
+      `);
+      const incident = stmt.get(id);
+      if (!incident) return null;
+      return {
+        ...incident,
+        components: JSON.parse(incident.components),
+      };
+    },
+
+    listIncidents({ status, limit = 100, offset = 0 } = {}) {
+      let query = `
+        SELECT id, title, description, components, status, impact, created_at, updated_at
+        FROM status_incidents
+      `;
+      const params = [];
+
+      if (status) {
+        query += ` WHERE status = ?`;
+        params.push(status);
+      }
+
+      query += ` ORDER BY created_at DESC LIMIT ? OFFSET ?`;
+      params.push(limit, offset);
+
+      const stmt = db.prepare(query);
+      const incidents = stmt.all(...params);
+      return incidents.map((incident) => ({
+        ...incident,
+        components: JSON.parse(incident.components),
+      }));
+    },
+
+    updateIncident({ id, title, description, components, status, impact, updatedAt }) {
+      const updates = [];
+      const params = [];
+
+      if (title !== undefined) {
+        updates.push('title = ?');
+        params.push(title);
+      }
+      if (description !== undefined) {
+        updates.push('description = ?');
+        params.push(description);
+      }
+      if (components !== undefined) {
+        updates.push('components = ?');
+        params.push(JSON.stringify(components));
+      }
+      if (status !== undefined) {
+        updates.push('status = ?');
+        params.push(status);
+      }
+      if (impact !== undefined) {
+        updates.push('impact = ?');
+        params.push(impact);
+      }
+
+      updates.push('updated_at = ?');
+      params.push(updatedAt);
+      params.push(id);
+
+      const stmt = db.prepare(`
+        UPDATE status_incidents
+        SET ${updates.join(', ')}
+        WHERE id = ?
+      `);
+      stmt.run(...params);
+    },
+
+    deleteIncident(id) {
+      const stmt = db.prepare(`DELETE FROM status_incidents WHERE id = ?`);
+      stmt.run(id);
+    },
+
+    // Incident Updates
+    createIncidentUpdate({ incidentId, status, message, timestamp }) {
+      const stmt = db.prepare(`
+        INSERT INTO status_incident_updates (incident_id, status, message, timestamp)
+        VALUES (?, ?, ?, ?)
+      `);
+      const result = stmt.run(incidentId, status, message, timestamp);
+      return { id: result.lastInsertRowid };
+    },
+
+    getIncidentUpdates(incidentId) {
+      const stmt = db.prepare(`
+        SELECT id, incident_id, status, message, timestamp
+        FROM status_incident_updates
+        WHERE incident_id = ?
+        ORDER BY timestamp ASC
+      `);
+      return stmt.all(incidentId);
+    },
+
+    // Maintenance
+    createMaintenance({ id, title, description, components, scheduledStart, scheduledEnd, createdAt }) {
+      const stmt = db.prepare(`
+        INSERT INTO status_maintenance (id, title, description, components, scheduled_start, scheduled_end, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(id, title, description, JSON.stringify(components), scheduledStart, scheduledEnd, createdAt);
+      return { id };
+    },
+
+    getMaintenance(id) {
+      const stmt = db.prepare(`
+        SELECT id, title, description, components, scheduled_start, scheduled_end, created_at
+        FROM status_maintenance
+        WHERE id = ?
+      `);
+      const maintenance = stmt.get(id);
+      if (!maintenance) return null;
+      return {
+        ...maintenance,
+        components: JSON.parse(maintenance.components),
+      };
+    },
+
+    listMaintenance({ limit = 100, offset = 0 } = {}) {
+      const stmt = db.prepare(`
+        SELECT id, title, description, components, scheduled_start, scheduled_end, created_at
+        FROM status_maintenance
+        ORDER BY scheduled_start ASC
+        LIMIT ? OFFSET ?
+      `);
+      const maintenanceList = stmt.all(limit, offset);
+      return maintenanceList.map((maintenance) => ({
+        ...maintenance,
+        components: JSON.parse(maintenance.components),
+      }));
+    },
+
+    deleteMaintenance(id) {
+      const stmt = db.prepare(`DELETE FROM status_maintenance WHERE id = ?`);
+      stmt.run(id);
+    },
+
+    // Subscribers
+    createSubscriber({ id, email, components, createdAt }) {
+      const stmt = db.prepare(`
+        INSERT INTO status_subscribers (id, email, components, created_at)
+        VALUES (?, ?, ?, ?)
+      `);
+      stmt.run(id, email, JSON.stringify(components), createdAt);
+      return { id };
+    },
+
+    getSubscriber(id) {
+      const stmt = db.prepare(`
+        SELECT id, email, components, created_at
+        FROM status_subscribers
+        WHERE id = ?
+      `);
+      const subscriber = stmt.get(id);
+      if (!subscriber) return null;
+      return {
+        ...subscriber,
+        components: JSON.parse(subscriber.components),
+      };
+    },
+
+    getSubscriberByEmail(email) {
+      const stmt = db.prepare(`
+        SELECT id, email, components, created_at
+        FROM status_subscribers
+        WHERE email = ?
+      `);
+      const subscriber = stmt.get(email);
+      if (!subscriber) return null;
+      return {
+        ...subscriber,
+        components: JSON.parse(subscriber.components),
+      };
+    },
+
+    listSubscribers({ limit = 100, offset = 0 } = {}) {
+      const stmt = db.prepare(`
+        SELECT id, email, components, created_at
+        FROM status_subscribers
+        ORDER BY created_at DESC
+        LIMIT ? OFFSET ?
+      `);
+      const subscribers = stmt.all(limit, offset);
+      return subscribers.map((subscriber) => ({
+        ...subscriber,
+        components: JSON.parse(subscriber.components),
+      }));
+    },
+
+    deleteSubscriber(id) {
+      const stmt = db.prepare(`DELETE FROM status_subscribers WHERE id = ?`);
+      stmt.run(id);
+    },
+  };
+}
diff --git a/backend/src/db/migrations/035_status_page.js b/backend/src/db/migrations/035_status_page.js
new file mode 100644
index 00000000..3d3f2063
--- /dev/null
+++ b/backend/src/db/migrations/035_status_page.js
@@ -0,0 +1,69 @@
+export const version = 35;
+export const description = 'Status page tables for incidents, maintenance, and subscriptions';
+
+export function up(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS status_incidents (
+      id                TEXT PRIMARY KEY,
+      title             TEXT    NOT NULL,
+      description       TEXT    NOT NULL,
+      components        TEXT    NOT NULL, -- JSON array of component IDs
+      status            TEXT    NOT NULL CHECK(status IN ('investigating', 'identified', 'monitoring', 'resolved')),
+      impact            TEXT    NOT NULL CHECK(impact IN ('none', 'minor', 'major', 'critical')),
+      created_at        TEXT    NOT NULL,
+      updated_at        TEXT    NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_status_incidents_status ON status_incidents(status);
+    CREATE INDEX IF NOT EXISTS idx_status_incidents_created_at ON status_incidents(created_at);
+
+    CREATE TABLE IF NOT EXISTS status_incident_updates (
+      id                INTEGER PRIMARY KEY AUTOINCREMENT,
+      incident_id       TEXT    NOT NULL,
+      status            TEXT    NOT NULL CHECK(status IN ('investigating', 'identified', 'monitoring', 'resolved')),
+      message           TEXT    NOT NULL,
+      timestamp         TEXT    NOT NULL,
+      FOREIGN KEY (incident_id) REFERENCES status_incidents(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_status_incident_updates_incident_id ON status_incident_updates(incident_id);
+
+    CREATE TABLE IF NOT EXISTS status_maintenance (
+      id                TEXT PRIMARY KEY,
+      title             TEXT    NOT NULL,
+      description       TEXT    NOT NULL,
+      components        TEXT    NOT NULL, -- JSON array of component IDs
+      scheduled_start   TEXT    NOT NULL,
+      scheduled_end     TEXT    NOT NULL,
+      created_at        TEXT    NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_status_maintenance_scheduled_start ON status_maintenance(scheduled_start);
+    CREATE INDEX IF NOT EXISTS idx_status_maintenance_scheduled_end ON status_maintenance(scheduled_end);
+
+    CREATE TABLE IF NOT EXISTS status_subscribers (
+      id                TEXT PRIMARY KEY,
+      email             TEXT    NOT NULL UNIQUE,
+      components        TEXT    NOT NULL, -- JSON array of component IDs to monitor
+      created_at        TEXT    NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_status_subscribers_email ON status_subscribers(email);
+  `);
+}
+
+export function down(db) {
+  db.exec(`
+    DROP INDEX IF EXISTS idx_status_subscribers_email;
+    DROP INDEX IF EXISTS idx_status_maintenance_scheduled_end;
+    DROP INDEX IF EXISTS idx_status_maintenance_scheduled_start;
+    DROP INDEX IF EXISTS idx_status_incident_updates_incident_id;
+    DROP INDEX IF EXISTS idx_status_incidents_created_at;
+    DROP INDEX IF EXISTS idx_status_incidents_status;
+
+    DROP TABLE IF EXISTS status_subscribers;
+    DROP TABLE IF EXISTS status_maintenance;
+    DROP TABLE IF EXISTS status_incident_updates;
+    DROP TABLE IF EXISTS status_incidents;
+  `);
+}
diff --git a/backend/src/index.js b/backend/src/index.js
index b4b25c74..34ee830e 100644
--- a/backend/src/index.js
+++ b/backend/src/index.js
@@ -102,7 +102,7 @@ import { createPruningJob } from './jobs/pruningJob.js';
 import { createModerationService } from './moderation/moderationService.js';
 import { createContentModerationMiddleware } from './middleware/contentModeration.js';
 import createFaucetRoutes from './routes/faucet.js';
-import createStatusRoutes from './routes/status.js';
+import createStatusRoutes, { setStatusRepository, setEventIndexer, setRpcPool } from './routes/status.js';
 import createWebhookRoutes from './routes/webhooks.js';
 
 const DEFAULT_PORT = 3001;
@@ -2738,6 +2738,9 @@ export async function createApp(options = {}) {
   app.use(`${API_V1_PREFIX}/webhooks`, createWebhookRoutes);
 
   // #818 — Public status page + incident communication
+  setStatusRepository(dal.status);
+  setEventIndexer(eventIndexer);
+  setRpcPool(rpcPool);
   app.use(`${API_V1_PREFIX}/status`, createStatusRoutes);
 
   registerApiRoutes(API_V1_PREFIX);
diff --git a/backend/src/routes/status.js b/backend/src/routes/status.js
index 7c23b7d8..343899bf 100644
--- a/backend/src/routes/status.js
+++ b/backend/src/routes/status.js
@@ -10,14 +10,22 @@ import { checkSorobanRpcHealth } from '../sorobanRpc.js';
 
 const router = Router();
 
-// In-memory storage (in production, use database)
-const incidents = new Map();
-const maintenanceNotices = new Map();
-const subscribers = new Map();
+// Will be injected by the main server
+let statusRepository = null;
+let eventIndexer = null;
+let rpcPool = null;
 
-let incidentIdCounter = 1;
-let maintenanceIdCounter = 1;
-let subscriberIdCounter = 1;
+export function setStatusRepository(repo) {
+  statusRepository = repo;
+}
+
+export function setEventIndexer(indexer) {
+  eventIndexer = indexer;
+}
+
+export function setRpcPool(pool) {
+  rpcPool = pool;
+}
 
 const COMPONENTS = [
   { id: 'api', name: 'API', description: 'REST API endpoints' },
@@ -54,6 +62,10 @@ const subscriberSchema = z.object({
  */
 router.get('/', async (req, res) => {
   try {
+    if (!statusRepository) {
+      return res.status(503).json({ error: 'Status repository not initialized' });
+    }
+
     // Check health of each component
     const componentStatus = await Promise.all(
       COMPONENTS.map(async (component) => {
@@ -72,15 +84,32 @@ router.get('/', async (req, res) => {
         } else if (component.id === 'api') {
           // API is operational if this endpoint responds
           status = 'operational';
-        } else {
-          // Default to operational for other components
+        } else if (component.id === 'indexer') {
+          // Check indexer health
+          if (eventIndexer) {
+            const health = eventIndexer.getHealth?.() ?? { status: 'unavailable' };
+            status = health.status === 'ok' || health.status === 'idle' ? 'operational' : 'degraded';
+          } else {
+            status = 'operational';
+          }
+        } else if (component.id === 'contracts') {
+          // Check RPC pool health for contracts
+          if (rpcPool) {
+            const poolStatus = rpcPool.getStatus();
+            status = poolStatus.healthy > 0 ? 'operational' : 'outage';
+          } else {
+            status = 'operational';
+          }
+        } else if (component.id === 'database') {
+          // Database is operational if we can query
           status = 'operational';
         }
 
         // Check if component is affected by active incidents
-        const activeIncidents = Array.from(incidents.values()).filter(
-          (inc) => inc.status !== 'resolved' && inc.components.includes(component.id),
-        );
+        const activeIncidents = statusRepository.listIncidents({ status: 'investigating' })
+          .concat(statusRepository.listIncidents({ status: 'identified' }))
+          .concat(statusRepository.listIncidents({ status: 'monitoring' }))
+          .filter((inc) => inc.components.includes(component.id));
 
         if (activeIncidents.length > 0) {
           const maxImpact = activeIncidents.reduce((max, inc) => {
@@ -101,14 +130,37 @@ router.get('/', async (req, res) => {
     );
 
     // Get active incidents
-    const activeIncidents = Array.from(incidents.values())
-      .filter((inc) => inc.status !== 'resolved')
-      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+    const investigatingIncidents = statusRepository.listIncidents({ status: 'investigating' });
+    const identifiedIncidents = statusRepository.listIncidents({ status: 'identified' });
+    const monitoringIncidents = statusRepository.listIncidents({ status: 'monitoring' });
+    const activeIncidents = [...investigatingIncidents, ...identifiedIncidents, ...monitoringIncidents]
+      .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+      .map((inc) => ({
+        id: inc.id,
+        title: inc.title,
+        description: inc.description,
+        components: inc.components,
+        status: inc.status,
+        impact: inc.impact,
+        createdAt: inc.created_at,
+        updatedAt: inc.updated_at,
+        updates: statusRepository.getIncidentUpdates(inc.id),
+      }));
 
     // Get scheduled maintenance
-    const scheduledMaintenance = Array.from(maintenanceNotices.values())
-      .filter((maint) => new Date(maint.scheduledEnd) > new Date())
-      .sort((a, b) => new Date(a.scheduledStart) - new Date(b.scheduledStart));
+    const allMaintenance = statusRepository.listMaintenance();
+    const scheduledMaintenance = allMaintenance
+      .filter((maint) => new Date(maint.scheduled_end) > new Date())
+      .sort((a, b) => new Date(a.scheduled_start) - new Date(b.scheduled_start))
+      .map((maint) => ({
+        id: maint.id,
+        title: maint.title,
+        description: maint.description,
+        components: maint.components,
+        scheduledStart: maint.scheduled_start,
+        scheduledEnd: maint.scheduled_end,
+        createdAt: maint.created_at,
+      }));
 
     // Calculate overall status
     const hasOutage = componentStatus.some((c) => c.status === 'outage');
@@ -133,14 +185,25 @@ router.get('/', async (req, res) => {
  * Get all incidents (including resolved)
  */
 router.get('/incidents', (req, res) => {
-  const { status } = req.query;
-  let incidentList = Array.from(incidents.values());
-
-  if (status) {
-    incidentList = incidentList.filter((inc) => inc.status === status);
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
   }
 
-  res.json(incidentList.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt)));
+  const { status } = req.query;
+  const incidents = statusRepository.listIncidents({ status })
+    .map((inc) => ({
+      id: inc.id,
+      title: inc.title,
+      description: inc.description,
+      components: inc.components,
+      status: inc.status,
+      impact: inc.impact,
+      createdAt: inc.created_at,
+      updatedAt: inc.updated_at,
+      updates: statusRepository.getIncidentUpdates(inc.id),
+    }));
+
+  res.json(incidents);
 });
 
 /**
@@ -148,33 +211,47 @@ router.get('/incidents', (req, res) => {
  * Create a new incident (admin only)
  */
 router.post('/incidents', async (req, res) => {
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
   try {
     const data = incidentSchema.parse(req.body);
-    const incidentId = `inc_${incidentIdCounter++}`;
+    const incidentId = `inc_${Date.now()}`;
+    const now = new Date().toISOString();
 
-    const incident = {
+    statusRepository.createIncident({
       id: incidentId,
       title: data.title,
       description: data.description,
       components: data.components,
       status: data.status,
       impact: data.impact,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      updates: [
-        {
-          status: data.status,
-          message: data.description,
-          timestamp: new Date().toISOString(),
-        },
-      ],
-    };
-
-    incidents.set(incidentId, incident);
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    statusRepository.createIncidentUpdate({
+      incidentId,
+      status: data.status,
+      message: data.description,
+      timestamp: now,
+    });
 
     log.info('Incident created', { incidentId, title: data.title, impact: data.impact });
 
-    res.status(201).json(incident);
+    const incident = statusRepository.getIncident(incidentId);
+    res.status(201).json({
+      id: incident.id,
+      title: incident.title,
+      description: incident.description,
+      components: incident.components,
+      status: incident.status,
+      impact: incident.impact,
+      createdAt: incident.created_at,
+      updatedAt: incident.updated_at,
+      updates: statusRepository.getIncidentUpdates(incidentId),
+    });
   } catch (error) {
     if (error instanceof z.ZodError) {
       return res.status(400).json({ error: 'Invalid request', details: error.errors });
@@ -189,7 +266,11 @@ router.post('/incidents', async (req, res) => {
  * Update an incident
  */
 router.put('/incidents/:id', async (req, res) => {
-  const incident = incidents.get(req.params.id);
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
+  const incident = statusRepository.getIncident(req.params.id);
   if (!incident) {
     return res.status(404).json({ error: 'Incident not found' });
   }
@@ -200,27 +281,40 @@ router.put('/incidents/:id', async (req, res) => {
     });
     const data = updateSchema.parse(req.body);
 
-    if (data.title) incident.title = data.title;
-    if (data.description) incident.description = data.description;
-    if (data.components) incident.components = data.components;
-    if (data.status) incident.status = data.status;
-    if (data.impact) incident.impact = data.impact;
-
-    incident.updatedAt = new Date().toISOString();
+    const now = new Date().toISOString();
+    statusRepository.updateIncident({
+      id: req.params.id,
+      title: data.title,
+      description: data.description,
+      components: data.components,
+      status: data.status,
+      impact: data.impact,
+      updatedAt: now,
+    });
 
     if (data.message || data.status) {
-      incident.updates.push({
+      statusRepository.createIncidentUpdate({
+        incidentId: req.params.id,
         status: data.status || incident.status,
         message: data.message || 'Status updated',
-        timestamp: new Date().toISOString(),
+        timestamp: now,
       });
     }
 
-    incidents.set(req.params.id, incident);
-
-    log.info('Incident updated', { incidentId: req.params.id, status: incident.status });
+    log.info('Incident updated', { incidentId: req.params.id, status: data.status || incident.status });
 
-    res.json(incident);
+    const updatedIncident = statusRepository.getIncident(req.params.id);
+    res.json({
+      id: updatedIncident.id,
+      title: updatedIncident.title,
+      description: updatedIncident.description,
+      components: updatedIncident.components,
+      status: updatedIncident.status,
+      impact: updatedIncident.impact,
+      createdAt: updatedIncident.created_at,
+      updatedAt: updatedIncident.updated_at,
+      updates: statusRepository.getIncidentUpdates(req.params.id),
+    });
   } catch (error) {
     if (error instanceof z.ZodError) {
       return res.status(400).json({ error: 'Invalid request', details: error.errors });
@@ -235,12 +329,16 @@ router.put('/incidents/:id', async (req, res) => {
  * Delete an incident
  */
 router.delete('/incidents/:id', (req, res) => {
-  const incident = incidents.get(req.params.id);
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
+  const incident = statusRepository.getIncident(req.params.id);
   if (!incident) {
     return res.status(404).json({ error: 'Incident not found' });
   }
 
-  incidents.delete(req.params.id);
+  statusRepository.deleteIncident(req.params.id);
   log.info('Incident deleted', { incidentId: req.params.id });
 
   res.status(204).send();
@@ -251,9 +349,20 @@ router.delete('/incidents/:id', (req, res) => {
  * Get all maintenance notices
  */
 router.get('/maintenance', (req, res) => {
-  const maintenanceList = Array.from(maintenanceNotices.values()).sort(
-    (a, b) => new Date(a.scheduledStart) - new Date(b.scheduledStart),
-  );
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
+  const maintenanceList = statusRepository.listMaintenance()
+    .map((maint) => ({
+      id: maint.id,
+      title: maint.title,
+      description: maint.description,
+      components: maint.components,
+      scheduledStart: maint.scheduled_start,
+      scheduledEnd: maint.scheduled_end,
+      createdAt: maint.created_at,
+    }));
 
   res.json(maintenanceList);
 });
@@ -263,25 +372,37 @@ router.get('/maintenance', (req, res) => {
  * Create a maintenance notice
  */
 router.post('/maintenance', async (req, res) => {
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
   try {
     const data = maintenanceSchema.parse(req.body);
-    const maintenanceId = `mnt_${maintenanceIdCounter++}`;
+    const maintenanceId = `mnt_${Date.now()}`;
+    const now = new Date().toISOString();
 
-    const maintenance = {
+    statusRepository.createMaintenance({
       id: maintenanceId,
       title: data.title,
       description: data.description,
       components: data.components,
       scheduledStart: data.scheduledStart,
       scheduledEnd: data.scheduledEnd,
-      createdAt: new Date().toISOString(),
-    };
-
-    maintenanceNotices.set(maintenanceId, maintenance);
+      createdAt: now,
+    });
 
     log.info('Maintenance notice created', { maintenanceId, title: data.title });
 
-    res.status(201).json(maintenance);
+    const maintenance = statusRepository.getMaintenance(maintenanceId);
+    res.status(201).json({
+      id: maintenance.id,
+      title: maintenance.title,
+      description: maintenance.description,
+      components: maintenance.components,
+      scheduledStart: maintenance.scheduled_start,
+      scheduledEnd: maintenance.scheduled_end,
+      createdAt: maintenance.created_at,
+    });
   } catch (error) {
     if (error instanceof z.ZodError) {
       return res.status(400).json({ error: 'Invalid request', details: error.errors });
@@ -296,12 +417,16 @@ router.post('/maintenance', async (req, res) => {
  * Delete a maintenance notice
  */
 router.delete('/maintenance/:id', (req, res) => {
-  const maintenance = maintenanceNotices.get(req.params.id);
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
+  const maintenance = statusRepository.getMaintenance(req.params.id);
   if (!maintenance) {
     return res.status(404).json({ error: 'Maintenance notice not found' });
   }
 
-  maintenanceNotices.delete(req.params.id);
+  statusRepository.deleteMaintenance(req.params.id);
   log.info('Maintenance notice deleted', { maintenanceId: req.params.id });
 
   res.status(204).send();
@@ -312,21 +437,31 @@ router.delete('/maintenance/:id', (req, res) => {
  * Subscribe to status updates
  */
 router.post('/subscribe', async (req, res) => {
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
   try {
     const data = subscriberSchema.parse(req.body);
-    const subscriberId = `sub_${subscriberIdCounter++}`;
+    const subscriberId = `sub_${Date.now()}`;
+    const now = new Date().toISOString();
 
-    const subscriber = {
+    // Check if email already subscribed
+    const existing = statusRepository.getSubscriberByEmail(data.email);
+    if (existing) {
+      return res.status(409).json({ error: 'Email already subscribed', id: existing.id });
+    }
+
+    statusRepository.createSubscriber({
       id: subscriberId,
       email: data.email,
       components: data.components || COMPONENTS.map((c) => c.id),
-      createdAt: new Date().toISOString(),
-    };
-
-    subscribers.set(subscriberId, subscriber);
+      createdAt: now,
+    });
 
     log.info('Status subscription created', { subscriberId, email: data.email });
 
+    const subscriber = statusRepository.getSubscriber(subscriberId);
     res.status(201).json({
       id: subscriber.id,
       email: subscriber.email,
@@ -347,12 +482,16 @@ router.post('/subscribe', async (req, res) => {
  * Unsubscribe from status updates
  */
 router.delete('/subscribe/:id', (req, res) => {
-  const subscriber = subscribers.get(req.params.id);
+  if (!statusRepository) {
+    return res.status(503).json({ error: 'Status repository not initialized' });
+  }
+
+  const subscriber = statusRepository.getSubscriber(req.params.id);
   if (!subscriber) {
     return res.status(404).json({ error: 'Subscription not found' });
   }
 
-  subscribers.delete(req.params.id);
+  statusRepository.deleteSubscriber(req.params.id);
   log.info('Status subscription deleted', { subscriberId: req.params.id });
 
   res.status(204).send();
diff --git a/backend/src/tests/status-simulation.test.js b/backend/src/tests/status-simulation.test.js
new file mode 100644
index 00000000..3f209644
--- /dev/null
+++ b/backend/src/tests/status-simulation.test.js
@@ -0,0 +1,277 @@
+/**
+ * Status page simulation test
+ * Simulates a dependency outage and verifies the status page reflects the degraded state
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { createDal } from '../dal/index.js';
+
+describe('Status Page Simulation Test', () => {
+  let dal;
+  let originalCheckSorobanRpcHealth;
+
+  before(async () => {
+    // Initialize DAL with in-memory database
+    dal = await createDal({ dbPath: ':memory:' });
+
+    // Mock the RPC health check function
+    originalCheckSorobanRpcHealth = global.checkSorobanRpcHealth;
+  });
+
+  after(async () => {
+    // Restore original function
+    if (originalCheckSorobanRpcHealth) {
+      global.checkSorobanRpcHealth = originalCheckSorobanRpcHealth;
+    }
+  });
+
+  it('should create an incident for RPC outage', () => {
+    const incidentId = `inc_${Date.now()}`;
+    const now = new Date().toISOString();
+
+    dal.status.createIncident({
+      id: incidentId,
+      title: 'Soroban RPC Outage',
+      description: 'Unable to connect to Soroban RPC endpoints',
+      components: ['rpc', 'contracts'],
+      status: 'investigating',
+      impact: 'critical',
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    dal.status.createIncidentUpdate({
+      incidentId,
+      status: 'investigating',
+      message: 'Investigating connectivity issues with Soroban RPC',
+      timestamp: now,
+    });
+
+    const incident = dal.status.getIncident(incidentId);
+    assert.ok(incident);
+    assert.equal(incident.title, 'Soroban RPC Outage');
+    assert.equal(incident.status, 'investigating');
+    assert.equal(incident.impact, 'critical');
+    assert.deepEqual(incident.components, ['rpc', 'contracts']);
+  });
+
+  it('should retrieve active incidents', () => {
+    const investigatingIncidents = dal.status.listIncidents({ status: 'investigating' });
+    assert.ok(investigatingIncidents.length > 0);
+    assert.equal(investigatingIncidents[0].status, 'investigating');
+  });
+
+  it('should update incident status through lifecycle', () => {
+    const incidents = dal.status.listIncidents({ status: 'investigating' });
+    assert.ok(incidents.length > 0);
+
+    const incidentId = incidents[0].id;
+    const now = new Date().toISOString();
+
+    // Update to identified
+    dal.status.updateIncident({
+      id: incidentId,
+      status: 'identified',
+      updatedAt: now,
+    });
+
+    dal.status.createIncidentUpdate({
+      incidentId,
+      status: 'identified',
+      message: 'Issue identified: DNS resolution failure for RPC endpoints',
+      timestamp: now,
+    });
+
+    const updated = dal.status.getIncident(incidentId);
+    assert.equal(updated.status, 'identified');
+
+    // Update to monitoring
+    const monitoringTime = new Date().toISOString();
+    dal.status.updateIncident({
+      id: incidentId,
+      status: 'monitoring',
+      updatedAt: monitoringTime,
+    });
+
+    dal.status.createIncidentUpdate({
+      incidentId,
+      status: 'monitoring',
+      message: 'Fix deployed, monitoring system stability',
+      timestamp: monitoringTime,
+    });
+
+    const monitoring = dal.status.getIncident(incidentId);
+    assert.equal(monitoring.status, 'monitoring');
+
+    // Update to resolved
+    const resolvedTime = new Date().toISOString();
+    dal.status.updateIncident({
+      id: incidentId,
+      status: 'resolved',
+      updatedAt: resolvedTime,
+    });
+
+    dal.status.createIncidentUpdate({
+      incidentId,
+      status: 'resolved',
+      message: 'Issue resolved, all systems operational',
+      timestamp: resolvedTime,
+    });
+
+    const resolved = dal.status.getIncident(incidentId);
+    assert.equal(resolved.status, 'resolved');
+  });
+
+  it('should create scheduled maintenance notice', () => {
+    const maintenanceId = `mnt_${Date.now()}`;
+    const now = new Date().toISOString();
+    const scheduledStart = new Date(Date.now() + 86400000).toISOString(); // Tomorrow
+    const scheduledEnd = new Date(Date.now() + 90000000).toISOString(); // Tomorrow + 1 hour
+
+    dal.status.createMaintenance({
+      id: maintenanceId,
+      title: 'Database Maintenance',
+      description: 'Scheduled database upgrade for performance improvements',
+      components: ['database'],
+      scheduledStart,
+      scheduledEnd,
+      createdAt: now,
+    });
+
+    const maintenance = dal.status.getMaintenance(maintenanceId);
+    assert.ok(maintenance);
+    assert.equal(maintenance.title, 'Database Maintenance');
+    assert.deepEqual(maintenance.components, ['database']);
+  });
+
+  it('should filter maintenance by scheduled time', () => {
+    const allMaintenance = dal.status.listMaintenance();
+    assert.ok(allMaintenance.length > 0);
+
+    // Filter for future maintenance
+    const futureMaintenance = allMaintenance.filter(
+      (m) => new Date(m.scheduled_end) > new Date(),
+    );
+    assert.ok(futureMaintenance.length > 0);
+  });
+
+  it('should handle subscriber lifecycle', () => {
+    const subscriberId = `sub_${Date.now()}`;
+    const now = new Date().toISOString();
+    const email = 'test@example.com';
+
+    dal.status.createSubscriber({
+      id: subscriberId,
+      email,
+      components: ['api', 'rpc', 'indexer'],
+      createdAt: now,
+    });
+
+    const subscriber = dal.status.getSubscriber(subscriberId);
+    assert.ok(subscriber);
+    assert.equal(subscriber.email, email);
+    assert.deepEqual(subscriber.components, ['api', 'rpc', 'indexer']);
+
+    // Check email lookup
+    const byEmail = dal.status.getSubscriberByEmail(email);
+    assert.ok(byEmail);
+    assert.equal(byEmail.id, subscriberId);
+
+    // Delete subscriber
+    dal.status.deleteSubscriber(subscriberId);
+    const deleted = dal.status.getSubscriber(subscriberId);
+    assert.equal(deleted, null);
+  });
+
+  it('should prevent duplicate email subscriptions', () => {
+    const email = 'duplicate@example.com';
+    const now = new Date().toISOString();
+
+    dal.status.createSubscriber({
+      id: `sub_${Date.now()}`,
+      email,
+      components: ['api'],
+      createdAt: now,
+    });
+
+    const existing = dal.status.getSubscriberByEmail(email);
+    assert.ok(existing);
+
+    // Attempting to create duplicate should be handled at the route level
+    // This test verifies the DAL correctly identifies existing subscriptions
+    assert.ok(existing);
+  });
+
+  it('should retrieve incident updates in chronological order', () => {
+    const incidentId = `inc_${Date.now()}`;
+    const now = new Date().toISOString();
+
+    dal.status.createIncident({
+      id: incidentId,
+      title: 'Test Incident',
+      description: 'Test description',
+      components: ['api'],
+      status: 'investigating',
+      impact: 'minor',
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    // Add multiple updates
+    dal.status.createIncidentUpdate({
+      incidentId,
+      status: 'investigating',
+      message: 'First update',
+      timestamp: new Date(Date.now() - 2000).toISOString(),
+    });
+
+    dal.status.createIncidentUpdate({
+      incidentId,
+      status: 'identified',
+      message: 'Second update',
+      timestamp: new Date(Date.now() - 1000).toISOString(),
+    });
+
+    dal.status.createIncidentUpdate({
+      incidentId,
+      status: 'monitoring',
+      message: 'Third update',
+      timestamp: now,
+    });
+
+    const updates = dal.status.getIncidentUpdates(incidentId);
+    assert.equal(updates.length, 3); // 3 updates created manually
+
+    // Verify chronological order
+    for (let i = 1; i < updates.length; i++) {
+      assert.ok(new Date(updates[i].timestamp) >= new Date(updates[i - 1].timestamp));
+    }
+  });
+
+  it('should simulate component status degradation based on incidents', () => {
+    // Create a critical incident affecting RPC
+    const incidentId = `inc_${Date.now()}`;
+    const now = new Date().toISOString();
+
+    dal.status.createIncident({
+      id: incidentId,
+      title: 'RPC Service Degradation',
+      description: 'High latency on RPC endpoints',
+      components: ['rpc'],
+      status: 'investigating',
+      impact: 'major',
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    const incident = dal.status.getIncident(incidentId);
+    assert.equal(incident.impact, 'major');
+    assert.ok(incident.components.includes('rpc'));
+
+    // Verify the incident affects the correct component
+    const activeIncidents = dal.status.listIncidents({ status: 'investigating' });
+    const rpcIncidents = activeIncidents.filter((inc) => inc.components.includes('rpc'));
+    assert.ok(rpcIncidents.length > 0);
+  });
+});
diff --git a/backend/trivela.db b/backend/trivela.db
index 7c4786a9..5eba9a2c 100644
Binary files a/backend/trivela.db and b/backend/trivela.db differ
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index 7b639d74..d73dfd06 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -21,6 +21,7 @@ const EmbedCampaign = lazy(() => import('./pages/EmbedCampaign'));
 const PublicProfile = lazy(() => import('./pages/PublicProfile'));
 const UserProfile = lazy(() => import('./pages/UserProfile'));
 const WebhookManagement = lazy(() => import('./pages/WebhookManagement'));
+const StatusPage = lazy(() => import('./pages/StatusPage'));
 import { applyTheme, getPreferredTheme, THEME_STORAGE_KEY } from './theme';
 import { getRuntimeConfig, initializeRuntimeConfig, setRuntimeStellarNetwork } from './config';
 import {
@@ -365,6 +366,7 @@ export default function App() {
           />
           <Route path="/embed/campaign/:id" element={<EmbedCampaign />} />
           <Route path="/u/:address" element={<PublicProfile />} />
+          <Route path="/status" element={<StatusPage />} />
           <Route
             path="/profile"
             element={
diff --git a/frontend/src/pages/StatusPage.jsx b/frontend/src/pages/StatusPage.jsx
new file mode 100644
index 00000000..ad23f1d6
--- /dev/null
+++ b/frontend/src/pages/StatusPage.jsx
@@ -0,0 +1,305 @@
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import PageMeta from '../components/PageMeta';
+
+const STATUS_COLORS = {
+  operational: 'bg-green-500',
+  degraded: 'bg-yellow-500',
+  outage: 'bg-red-500',
+};
+
+const STATUS_TEXT = {
+  operational: 'Operational',
+  degraded: 'Degraded',
+  outage: 'Outage',
+};
+
+const IMPACT_COLORS = {
+  none: 'text-gray-500',
+  minor: 'text-yellow-600',
+  major: 'text-orange-600',
+  critical: 'text-red-600',
+};
+
+const IMPACT_BADGES = {
+  none: 'bg-gray-100 text-gray-800',
+  minor: 'bg-yellow-100 text-yellow-800',
+  major: 'bg-orange-100 text-orange-800',
+  critical: 'bg-red-100 text-red-800',
+};
+
+const INCIDENT_STATUS_COLORS = {
+  investigating: 'bg-yellow-100 text-yellow-800',
+  identified: 'bg-orange-100 text-orange-800',
+  monitoring: 'bg-blue-100 text-blue-800',
+  resolved: 'bg-green-100 text-green-800',
+};
+
+export default function StatusPage() {
+  const { t } = useTranslation();
+  const [statusData, setStatusData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [email, setEmail] = useState('');
+  const [subscribing, setSubscribing] = useState(false);
+  const [subscribeMessage, setSubscribeMessage] = useState(null);
+
+  const API_BASE = import.meta.env.VITE_API_URL || 'http://localhost:3001';
+
+  useEffect(() => {
+    fetchStatus();
+    const interval = setInterval(fetchStatus, 30000); // Refresh every 30 seconds
+    return () => clearInterval(interval);
+  }, []);
+
+  const fetchStatus = async () => {
+    try {
+      const response = await fetch(`${API_BASE}/api/v1/status`);
+      if (!response.ok) throw new Error('Failed to fetch status');
+      const data = await response.json();
+      setStatusData(data);
+      setError(null);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleSubscribe = async (e) => {
+    e.preventDefault();
+    if (!email) return;
+
+    setSubscribing(true);
+    setSubscribeMessage(null);
+
+    try {
+      const response = await fetch(`${API_BASE}/api/v1/status/subscribe`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email }),
+      });
+
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || 'Subscription failed');
+      }
+
+      setSubscribeMessage({ type: 'success', message: 'Successfully subscribed to status updates!' });
+      setEmail('');
+    } catch (err) {
+      setSubscribeMessage({ type: 'error', message: err.message });
+    } finally {
+      setSubscribing(false);
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className="min-h-screen bg-gray-50 flex items-center justify-center">
+        <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600"></div>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="min-h-screen bg-gray-50 flex items-center justify-center">
+        <div className="text-center">
+          <p className="text-red-600 mb-4">Error loading status page</p>
+          <button
+            onClick={fetchStatus}
+            className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+          >
+            Retry
+          </button>
+        </div>
+      </div>
+    );
+  }
+
+  const overallStatus = statusData?.status || 'operational';
+
+  return (
+    <>
+      <PageMeta
+        title="System Status"
+        description="Real-time status of Trivela platform services and components"
+      />
+      <div className="min-h-screen bg-gray-50">
+        {/* Header */}
+        <div className="bg-white border-b">
+          <div className="max-w-6xl mx-auto px-4 py-8">
+            <div className="flex items-center justify-between">
+              <div>
+                <h1 className="text-3xl font-bold text-gray-900">System Status</h1>
+                <p className="text-gray-600 mt-1">Real-time service availability and incident updates</p>
+              </div>
+              <div className="flex items-center gap-2">
+                <span className={`h-3 w-3 rounded-full ${STATUS_COLORS[overallStatus]}`}></span>
+                <span className={`font-semibold ${IMPACT_COLORS[overallStatus]}`}>
+                  {STATUS_TEXT[overallStatus]}
+                </span>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <div className="max-w-6xl mx-auto px-4 py-8">
+          {/* Components */}
+          <div className="bg-white rounded-lg shadow mb-8">
+            <div className="px-6 py-4 border-b">
+              <h2 className="text-xl font-semibold text-gray-900">Components</h2>
+            </div>
+            <div className="divide-y">
+              {statusData?.components?.map((component) => (
+                <div key={component.id} className="px-6 py-4 flex items-center justify-between">
+                  <div>
+                    <h3 className="font-medium text-gray-900">{component.name}</h3>
+                    <p className="text-sm text-gray-500">{component.description}</p>
+                  </div>
+                  <div className="flex items-center gap-3">
+                    {component.latency && (
+                      <span className="text-sm text-gray-500">{component.latency}ms</span>
+                    )}
+                    <div className="flex items-center gap-2">
+                      <span className={`h-2 w-2 rounded-full ${STATUS_COLORS[component.status]}`}></span>
+                      <span className={`text-sm font-medium ${IMPACT_COLORS[component.status]}`}>
+                        {STATUS_TEXT[component.status]}
+                      </span>
+                    </div>
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {/* Active Incidents */}
+          {statusData?.incidents && statusData.incidents.length > 0 && (
+            <div className="bg-white rounded-lg shadow mb-8">
+              <div className="px-6 py-4 border-b">
+                <h2 className="text-xl font-semibold text-gray-900">Active Incidents</h2>
+              </div>
+              <div className="divide-y">
+                {statusData.incidents.map((incident) => (
+                  <div key={incident.id} className="px-6 py-4">
+                    <div className="flex items-start justify-between mb-2">
+                      <div>
+                        <h3 className="font-medium text-gray-900">{incident.title}</h3>
+                        <div className="flex items-center gap-2 mt-1">
+                          <span className={`px-2 py-1 rounded text-xs font-medium ${INCIDENT_STATUS_COLORS[incident.status]}`}>
+                            {incident.status.charAt(0).toUpperCase() + incident.status.slice(1)}
+                          </span>
+                          <span className={`px-2 py-1 rounded text-xs font-medium ${IMPACT_BADGES[incident.impact]}`}>
+                            {incident.impact.charAt(0).toUpperCase() + incident.impact.slice(1)} Impact
+                          </span>
+                        </div>
+                      </div>
+                      <span className="text-sm text-gray-500">
+                        {new Date(incident.updatedAt).toLocaleString()}
+                      </span>
+                    </div>
+                    <p className="text-gray-600 mb-3">{incident.description}</p>
+                    {incident.updates && incident.updates.length > 0 && (
+                      <div className="bg-gray-50 rounded p-3">
+                        <h4 className="text-sm font-medium text-gray-700 mb-2">Updates</h4>
+                        <div className="space-y-2">
+                          {incident.updates.map((update, idx) => (
+                            <div key={idx} className="text-sm">
+                              <span className="text-gray-500">
+                                {new Date(update.timestamp).toLocaleString()} -{' '}
+                              </span>
+                              <span className="text-gray-700">{update.message}</span>
+                            </div>
+                          ))}
+                        </div>
+                      </div>
+                    )}
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {/* Scheduled Maintenance */}
+          {statusData?.maintenance && statusData.maintenance.length > 0 && (
+            <div className="bg-white rounded-lg shadow mb-8">
+              <div className="px-6 py-4 border-b">
+                <h2 className="text-xl font-semibold text-gray-900">Scheduled Maintenance</h2>
+              </div>
+              <div className="divide-y">
+                {statusData.maintenance.map((maintenance) => (
+                  <div key={maintenance.id} className="px-6 py-4">
+                    <div className="flex items-start justify-between mb-2">
+                      <div>
+                        <h3 className="font-medium text-gray-900">{maintenance.title}</h3>
+                        <p className="text-sm text-gray-500 mt-1">
+                          {new Date(maintenance.scheduledStart).toLocaleString()} -{' '}
+                          {new Date(maintenance.scheduledEnd).toLocaleString()}
+                        </p>
+                      </div>
+                      <span className="text-sm text-gray-500">
+                        {new Date(maintenance.createdAt).toLocaleString()}
+                      </span>
+                    </div>
+                    <p className="text-gray-600">{maintenance.description}</p>
+                    <div className="mt-2 flex flex-wrap gap-2">
+                      {maintenance.components.map((comp) => (
+                        <span
+                          key={comp}
+                          className="px-2 py-1 bg-blue-50 text-blue-700 rounded text-xs"
+                        >
+                          {comp}
+                        </span>
+                      ))}
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {/* Subscribe */}
+          <div className="bg-white rounded-lg shadow p-6">
+            <h2 className="text-xl font-semibold text-gray-900 mb-4">Subscribe to Updates</h2>
+            <p className="text-gray-600 mb-4">
+              Get notified about incidents and maintenance windows via email.
+            </p>
+            <form onSubmit={handleSubscribe} className="flex gap-3">
+              <input
+                type="email"
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+                placeholder="Enter your email"
+                className="flex-1 px-4 py-2 border rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+                disabled={subscribing}
+              />
+              <button
+                type="submit"
+                disabled={subscribing || !email}
+                className="px-6 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:bg-gray-300 disabled:cursor-not-allowed"
+              >
+                {subscribing ? 'Subscribing...' : 'Subscribe'}
+              </button>
+            </form>
+            {subscribeMessage && (
+              <p
+                className={`mt-2 text-sm ${
+                  subscribeMessage.type === 'success' ? 'text-green-600' : 'text-red-600'
+                }`}
+              >
+                {subscribeMessage.message}
+              </p>
+            )}
+          </div>
+
+          {/* Footer */}
+          <div className="mt-8 text-center text-sm text-gray-500">
+            <p>Last updated: {statusData?.lastUpdated ? new Date(statusData.lastUpdated).toLocaleString() : 'N/A'}</p>
+            <p className="mt-1">Page refreshes automatically every 30 seconds</p>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/package-lock.json b/package-lock.json
index 8aa6a190..da6fa469 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14741,6 +14741,15 @@
       "integrity": "sha512-qcUXuemtEu+E5wZSJHNxUXeCZhAfXKQ41D+duX+VYPde7xyEVZci+/oXKJL13tnRs9lR2pr4fod59GT6/X1/yQ==",
       "dev": true
     },
+    "node_modules/redoc-cli/node_modules/@types/mkdirp": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@types/mkdirp/-/mkdirp-1.0.1.tgz",
+      "integrity": "sha512-HkGSK7CGAXncr8Qn/0VqNtExEE+PHMWb+qlR1faHMao7ng6P3tAaoWWBMdva0gL5h4zprjIO89GJOLXsMcDm1Q==",
+      "extraneous": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/redoc-cli/node_modules/@types/node": {
       "version": "15.12.2",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-15.12.2.tgz",