Design A Smart Home System - System Design

System requirements

Functional:

Users can register, pair, and manage devices (Wi-Fi, Zigbee, Z-Wave, Thread, Matter).
Users can control devices (on/off, brightness, temperature, lock/unlock) via app or voice.
System supports scheduling and automation (time-based, triggers, conditions, actions).
Users can access devices remotely through mobile/web apps.
System integrates with voice assistants (Alexa, Google, Siri).
Provide energy usage monitoring per device and household.
Support home security features (cameras, motion sensors, door locks, alarms).
Provide notifications and alerts (push, SMS, email).

Non-Functional:

Interoperability: Work with multiple device protocols and ecosystems.
Performance: Commands execute within <1 second under normal conditions.
Reliability: Core automations must work even if cloud is offline (local hub fallback).
Scalability: Support thousands of devices per home and millions of users globally.
Security & Privacy: End-to-end encryption, role-based access, GDPR compliance.
Availability: Cloud backend uptime target 99.9%.
Usability: Simple, intuitive mobile/web UI for non-technical users.

Capacity estimation

Capacity Estimation (1M Homes)

Homes: 1M
Devices: ~20 per home → 20M devices

Messaging

Telemetry: 15 devices/home → 500K msgs/sec peak
Commands/state changes: ~600/sec (small load)

Storage

Telemetry (~200B/msg): 8.6 TB/day → 780 TB for 90 days hot storage
Video (10% homes, 1 min/day): ~22 TB/month

Bandwidth

Inbound: ~100 MB/sec
Outbound: ~120 MB/sec

Infrastructure

MQTT Cluster: 10–15 broker nodes
Event Stream: Kafka cluster + 50–100 rule workers
DBs: Timescale/Influx for telemetry (~1 PB scale), Postgres for metadata, Redis for caching
Multi-region, 99.9% uptime target

API design

Authentication

POST /auth/token — OAuth2 token exchange (clients).
POST /auth/device — device enroll with cert or provisioning token.

Device management

GET /homes/{homeId}/devices
GET /homes/{homeId}/devices/{deviceId}
POST /homes/{homeId}/devices/{deviceId}/commands
GET /homes/{homeId}/devices/{deviceId}/state

Telemetry & history

GET /homes/{homeId}/devices/{deviceId}/telemetry?from=...&to=...&metric=power

Automation & scheduling

POST /homes/{homeId}/rules — create rule (body = DSL)
GET /homes/{homeId}/rules/{ruleId}
POST /homes/{homeId}/schedules — create scheduled scene

WebSocket / Realtime

ws /realtime?token=... — subscribe to home/{homeId}/events channels.

Database design

Relational DB (Postgres/MySQL) – Core Metadata

Stores structured, relational data (users, homes, devices, rules, schedules).

  "users": {
    "user_id": "uuid",
    "email": "string",
    "password_hash": "string",
    "role": "owner | admin | guest",
    "created_at": "timestamp"
  }

  "homes": {
    "home_id": "uuid",
    "user_id": "uuid (FK -> users.user_id)",
    "name": "string",
    "timezone": "string"
  }

  "devices": {
    "device_id": "uuid",
    "home_id": "uuid (FK -> homes.home_id)",
    "type": "light | thermostat | lock | camera | sensor",
    "protocol": "wifi | zigbee | zwave | thread | matter",
    "manufacturer": "string",
    "model": "string",
    "firmware": "string",
    "status": {
      "power": "on | off",
      "brightness": "int",
      "temperature": "float",
      "lock_state": "locked | unlocked"
    },
    "last_seen": "timestamp"
  }

  "automation_rules": {
    "rule_id": "uuid",
    "home_id": "uuid (FK -> homes.home_id)",
    "name": "string",
    "trigger": {
      "type": "motion | schedule | sunset | sensor",
      "device_id": "uuid",
      "property": "string",
      "operator": ">, <, =, !=, etc.",
      "value": "any"
    },
    "conditions": [
      {
        "device_id": "uuid",
        "property": "string",
        "operator": "string",
        "value": "any"
      }
    ],
    "actions": [
      {
        "device_id": "uuid",
        "command": "turn_on | turn_off | set_temp | notify",
        "params": {}
      }
    ],
    "enabled": "boolean"
  },

  "schedules": {
    "schedule_id": "uuid",
    "home_id": "uuid (FK -> homes.home_id)",
    "device_id": "uuid (FK -> devices.device_id)",
    "cron_expr": "string (e.g., '0 7 * * *')",
    "action": {
      "command": "turn_on | turn_off",
      "params": {}
    }
  }

Time-Series DB (TimescaleDB/InfluxDB) – Telemetry

Stores sensor readings & device telemetry.

  "telemetry": {
    "ts": "timestamp",
    "device_id": "uuid (FK -> devices.device_id)",
    "metric": "temperature | humidity | power | motion",
    "value": "float",
    "unit": "°C | % | W | kWh"
  },
  "media_files": {
    "media_id": "uuid",
    "device_id": "uuid (FK -> devices.device_id)",
    "type": "snapshot | clip",
    "url": "string (S3/GCS path)",
    "created_at": "timestamp"
  }

High-level design

Edge node layer

This is where physical devices exist inside the home.

Wi-Fi Devices - devices that connect directly to the cloud or local hub via Wi-Fi.
Smart Home Hub (Zigbee / Z-Wave / Thread) - A bridge to connect low-power devices (Zigbee, Z-Wave, Thread) to the cloud.
Zigbee / Z-Wave Devices - Smart bulbs, sensors, locks, etc., that talk to the hub.

Cloud Layer

This is the backend system that manages communication, automation, storage, and integration.

API Gateway & Auth - Entry point for mobile apps, third-party integrations, and authentication (OAuth, REST, WebSocket).
Command Service - Processes device control commands (e.g., turn on lights).
Message Broker / MQTT Cluster - Routes messages between devices and services.
Kafka - Streams events in real time for processing.
Scheduler Service - Triggers time-based tasks (e.g., "turn on lights at 7 PM").
Automation Engine - Executes user-defined automations (IFTTT-style rules).
Device cfg - Keeps track of registered devices, states, and metadata.
Relational DB (Configs) - Stores user accounts, device configs, and rules.
Time-Series DB - Stores sensor readings and telemetry data over time.
Object Storage (cold archive) - Long-term storage for large datasets or historical logs.
Notification Service - Push notifications, alerts, or emails.

Clients

How users and assistants interact with the system.

User Mobile / Web App - Directly communicates with the API Gateway for device control, monitoring, and configuration.
Voice Assistant Clouds (Alexa, Google) - Use OAuth skill integrations to control devices through the system.

Request flows

Explain how the request flows from end to end in your high level design. Also you could draw a sequence diagram using the diagramming tool to enhance your explanation...

Detailed component design

Dig deeper into 2-3 components and explain in detail how they work. For example, how well does each component scale? Any relevant algorithm or data structure you like to use for a component? Also you could draw a diagram using the diagramming tool to enhance your design...

Trade offs/Tech choices

Explain any trade offs you have made and why you made certain tech choices...

Failure scenarios/bottlenecks

Try to discuss as many failure scenarios/bottlenecks as possible.

Future improvements

What are some future improvements you would make? How would you mitigate the failure scenario(s) you described above?