89  IoT Architecture Planner

Interactive Tool for Designing End-to-End IoT Systems

89.1 IoT Architecture Planner

NoteLearning Objectives

By using this interactive tool, you will be able to:

• Design complete IoT architectures from sensors to cloud applications
• Make informed decisions about edge vs. cloud processing trade-offs
• Estimate costs for different architectural approaches
• Identify potential bottlenecks in data flow and processing
• Generate architecture diagrams for your IoT projects

NoteKey Takeaway

In one sentence: A well-designed IoT architecture balances sensing needs, connectivity options, processing location, and cost constraints across five interconnected layers.

Remember this rule: Process data at the edge when latency matters, send to cloud when you need scale - your architecture should optimize the edge/cloud split for your specific requirements.

89.2 Prerequisites

Before using this planner, review:

• IoT Reference Models: Understanding of IoT architecture layers
• Edge-Fog Computing: Edge vs. cloud processing concepts
• Protocol Selector Wizard: Choose connectivity before designing architecture

TipFor Beginners: IoT Architecture = Blueprint for Your System

Simple Analogy: Building a House

Designing IoT architecture is like planning a house:

House Component	IoT Equivalent	Purpose
Sensors (smoke, motion)	IoT Sensors	Detect what’s happening
Wiring	Network/Protocols	Connect everything
Electrical panel	Gateway/Edge	Process locally
Utility connection	Cloud Services	Connect to outside world
Smart home app	Dashboard/App	Control and monitor

Three Architecture Patterns:

1. Direct-to-Cloud: Sensors → Cloud (simple, but needs internet)
2. Gateway-Based: Sensors → Gateway → Cloud (most common)
3. Edge-Heavy: Sensors → Edge Processing → Cloud (smart, less data)

---

89.3 Step 1: Define Your Application

viewof arch_app = Inputs.select(
  [
    "Smart Home / Building",
    "Industrial Manufacturing",
    "Smart Agriculture",
    "Healthcare / Wearables",
    "Smart City / Infrastructure",
    "Retail / Logistics",
    "Energy / Utilities",
    "Transportation / Fleet",
    "Environmental Monitoring",
    "Custom Application"
  ],
  {label: "Application Domain:", value: "Smart Home / Building"}
)

viewof arch_scale = Inputs.select(
  [
    "Single location (1 site)",
    "Multiple locations (2-10 sites)",
    "Regional (10-50 sites)",
    "National (50-200 sites)",
    "Global (200+ sites)"
  ],
  {label: "Deployment Scale:", value: "Single location (1 site)"}
)

viewof arch_criticality = Inputs.select(
  [
    "Non-critical (data loss acceptable)",
    "Important (some data loss OK)",
    "Business-critical (minimal data loss)",
    "Mission-critical (no data loss)",
    "Safety-critical (life-safety)"
  ],
  {label: "System Criticality:", value: "Important (some data loss OK)"}
)

---

89.4 Step 2: Sensing Layer

NoteLayer 1: Sensors and Actuators

The perception layer captures physical world data and executes actions.

viewof sensor_count = Inputs.range([1, 10000], {
  label: "Number of Sensors:",
  value: 50,
  step: 1
})

viewof sensor_types = Inputs.checkbox(
  ["Temperature", "Humidity", "Motion/PIR", "Light/Luminosity", "Pressure", "Vibration", "GPS/Location", "Camera/Video", "Audio/Sound", "Air Quality", "Water/Moisture", "Power/Energy"],
  {label: "Sensor Types:", value: ["Temperature", "Humidity", "Motion/PIR"]}
)

viewof actuator_count = Inputs.range([0, 500], {
  label: "Number of Actuators:",
  value: 10,
  step: 1
})

viewof actuator_types = Inputs.checkbox(
  ["Relays/Switches", "Motors/Servos", "Valves", "Displays/LEDs", "Speakers/Alarms", "HVAC Controls", "Locks/Access"],
  {label: "Actuator Types:", value: ["Relays/Switches", "Displays/LEDs"]}
)

// Data characteristics
viewof data_rate = Inputs.select(
  [
    "Low (< 1 msg/min per sensor)",
    "Medium (1-10 msg/min)",
    "High (10-60 msg/min)",
    "Very High (> 1 msg/sec)",
    "Streaming (continuous)"
  ],
  {label: "Data Frequency:", value: "Medium (1-10 msg/min)"}
)

viewof data_size = Inputs.select(
  [
    "Tiny (< 100 bytes)",
    "Small (100 bytes - 1 KB)",
    "Medium (1-10 KB)",
    "Large (10-100 KB)",
    "Very Large (> 100 KB, images/video)"
  ],
  {label: "Message Size:", value: "Tiny (< 100 bytes)"}
)

---

89.5 Step 3: Network Layer

NoteLayer 2: Connectivity

How sensors connect and communicate data.

viewof primary_protocol = Inputs.select(
  [
    "Wi-Fi (802.11)",
    "Bluetooth LE",
    "Zigbee",
    "Thread",
    "Z-Wave",
    "LoRaWAN",
    "NB-IoT",
    "LTE-M",
    "Sigfox",
    "Ethernet (Wired)",
    "Mixed/Multiple"
  ],
  {label: "Primary Connectivity:", value: "Wi-Fi (802.11)"}
)

viewof gateway_needed = Inputs.select(
  [
    "No gateway (direct to cloud)",
    "Simple gateway (protocol translation)",
    "Smart gateway (local processing)",
    "Edge server (heavy processing)",
    "Multiple gateway tiers"
  ],
  {label: "Gateway Architecture:", value: "Smart gateway (local processing)"}
)

viewof gateway_count = Inputs.range([0, 100], {
  label: "Number of Gateways:",
  value: 3,
  step: 1
})

viewof backhaul = Inputs.select(
  [
    "Wi-Fi to broadband",
    "Ethernet",
    "Cellular (4G/5G)",
    "Satellite",
    "LoRaWAN network server",
    "Fiber"
  ],
  {label: "Backhaul Connection:", value: "Wi-Fi to broadband"}
)

---

89.6 Step 4: Processing Layer

NoteLayer 3: Where to Process Data

Decide between edge, fog, and cloud processing.

viewof edge_processing = Inputs.range([0, 100], {
  label: "Edge Processing (%):",
  value: 30,
  step: 5
})

viewof edge_tasks = Inputs.checkbox(
  [
    "Data filtering/aggregation",
    "Local analytics/alerts",
    "Protocol translation",
    "Data compression",
    "ML inference",
    "Video analytics",
    "Local control loops",
    "Buffering/store-forward"
  ],
  {label: "Edge Tasks:", value: ["Data filtering/aggregation", "Local analytics/alerts", "Protocol translation"]}
)

viewof cloud_services = Inputs.checkbox(
  [
    "Data storage (time-series DB)",
    "Long-term analytics",
    "ML model training",
    "Dashboards/visualization",
    "API services",
    "User management",
    "Device management",
    "Integration services"
  ],
  {label: "Cloud Services:", value: ["Data storage (time-series DB)", "Dashboards/visualization", "Device management"]}
)

viewof latency_requirement = Inputs.select(
  [
    "Not critical (seconds OK)",
    "Near real-time (< 1 second)",
    "Real-time (< 100 ms)",
    "Ultra-low (< 10 ms)",
    "Deterministic (< 1 ms)"
  ],
  {label: "Latency Requirement:", value: "Near real-time (< 1 second)"}
)

---

89.7 Step 5: Application Layer

NoteLayer 4: Business Applications

End-user applications and integrations.

viewof app_interfaces = Inputs.checkbox(
  [
    "Web dashboard",
    "Mobile app (iOS/Android)",
    "REST API",
    "MQTT broker access",
    "Webhooks/notifications",
    "Voice assistant integration",
    "Third-party integrations",
    "Enterprise system (ERP/CRM)"
  ],
  {label: "Application Interfaces:", value: ["Web dashboard", "Mobile app (iOS/Android)", "REST API"]}
)

viewof user_types = Inputs.checkbox(
  [
    "End consumers",
    "Technicians/installers",
    "Operators/managers",
    "Data analysts",
    "Administrators",
    "API developers"
  ],
  {label: "User Types:", value: ["End consumers", "Operators/managers"]}
)

viewof data_retention = Inputs.select(
  [
    "7 days (short-term)",
    "30 days (monthly)",
    "90 days (quarterly)",
    "1 year (annual)",
    "3 years (compliance)",
    "7+ years (long-term archive)"
  ],
  {label: "Data Retention:", value: "1 year (annual)"}
)

---

89.8 Architecture Visualization

arch_metrics = {
  // Data volume calculations
  let msgs_per_min = data_rate.includes("Low") ? 0.5 :
                     data_rate.includes("Medium") ? 5 :
                     data_rate.includes("High") ? 30 :
                     data_rate.includes("Very High") ? 120 : 600;

  let msg_bytes = data_size.includes("Tiny") ? 50 :
                  data_size.includes("Small") ? 500 :
                  data_size.includes("Medium") ? 5000 :
                  data_size.includes("Large") ? 50000 : 500000;

  let daily_msgs = sensor_count * msgs_per_min * 60 * 24;
  let daily_bytes = daily_msgs * msg_bytes;
  let monthly_gb = (daily_bytes * 30) / (1024 * 1024 * 1024);

  // Data after edge processing
  let cloud_data_pct = (100 - edge_processing) / 100;
  let cloud_monthly_gb = monthly_gb * cloud_data_pct;

  // Gateway capacity
  let sensors_per_gateway = gateway_count > 0 ? Math.ceil(sensor_count / gateway_count) : sensor_count;

  // Redundancy needs
  let redundancy = arch_criticality.includes("Mission") || arch_criticality.includes("Safety") ? "High (N+1 or N+2)" :
                   arch_criticality.includes("Business") ? "Medium (N+1)" : "Low (single)";

  // Latency estimate
  let edge_latency = edge_processing > 50 ? 20 : 50;
  let cloud_latency = backhaul.includes("Satellite") ? 600 :
                      backhaul.includes("Cellular") ? 100 :
                      backhaul.includes("Wi-Fi") ? 50 : 30;
  let total_latency = edge_processing > 50 ? edge_latency : edge_latency + cloud_latency;

  return {
    daily_msgs: daily_msgs.toLocaleString(),
    daily_gb: (daily_bytes / (1024 * 1024 * 1024)).toFixed(2),
    monthly_gb: monthly_gb.toFixed(2),
    cloud_monthly_gb: cloud_monthly_gb.toFixed(2),
    sensors_per_gateway: sensors_per_gateway,
    redundancy: redundancy,
    edge_latency: edge_latency,
    cloud_latency: cloud_latency,
    total_latency: total_latency,
    data_reduction: (edge_processing) + '%'
  };
}

html`
<div style="background: linear-gradient(135deg, #E8F6F3 0%, #D5F4E6 100%); padding: 25px; border-radius: 12px; margin: 20px 0; border: 2px solid #16A085;">
  <h3 style="color: #16A085; margin-top: 0;">🏗️ Your IoT Architecture</h3>

  <!-- Architecture Diagram -->
  <div style="background: white; padding: 20px; border-radius: 10px; margin: 15px 0;">
    <h4 style="color: #2C3E50; margin-top: 0;">Architecture Overview</h4>
    <div style="display: flex; justify-content: space-between; align-items: center; flex-wrap: wrap; gap: 10px; padding: 20px 0;">

      <!-- Sensing Layer -->
      <div style="text-align: center; flex: 1; min-width: 120px;">
        <div style="background: #16A085; color: white; padding: 15px; border-radius: 10px; margin-bottom: 10px;">
          <div style="font-size: 2em;">📡</div>
          <div style="font-weight: bold;">Sensors</div>
          <div style="font-size: 0.9em;">${sensor_count} devices</div>
        </div>
        <div style="font-size: 0.85em; color: #666;">
          ${sensor_types.slice(0, 3).join(', ')}${sensor_types.length > 3 ? '...' : ''}
        </div>
      </div>

      <div style="font-size: 2em; color: #16A085;">→</div>

      <!-- Network Layer -->
      <div style="text-align: center; flex: 1; min-width: 120px;">
        <div style="background: #2C3E50; color: white; padding: 15px; border-radius: 10px; margin-bottom: 10px;">
          <div style="font-size: 2em;">📶</div>
          <div style="font-weight: bold;">${primary_protocol}</div>
          <div style="font-size: 0.9em;">${gateway_count} gateways</div>
        </div>
        <div style="font-size: 0.85em; color: #666;">
          ${gateway_needed.split('(')[0]}
        </div>
      </div>

      <div style="font-size: 2em; color: #16A085;">→</div>

      <!-- Processing Layer -->
      <div style="text-align: center; flex: 1; min-width: 120px;">
        <div style="background: #E67E22; color: white; padding: 15px; border-radius: 10px; margin-bottom: 10px;">
          <div style="font-size: 2em;">⚙️</div>
          <div style="font-weight: bold;">Processing</div>
          <div style="font-size: 0.9em;">${edge_processing}% edge</div>
        </div>
        <div style="font-size: 0.85em; color: #666;">
          ${edge_tasks.slice(0, 2).join(', ')}
        </div>
      </div>

      <div style="font-size: 2em; color: #16A085;">→</div>

      <!-- Cloud Layer -->
      <div style="text-align: center; flex: 1; min-width: 120px;">
        <div style="background: #3498DB; color: white; padding: 15px; border-radius: 10px; margin-bottom: 10px;">
          <div style="font-size: 2em;">☁️</div>
          <div style="font-weight: bold;">Cloud</div>
          <div style="font-size: 0.9em;">${arch_metrics.cloud_monthly_gb} GB/mo</div>
        </div>
        <div style="font-size: 0.85em; color: #666;">
          ${cloud_services.slice(0, 2).join(', ')}
        </div>
      </div>

      <div style="font-size: 2em; color: #16A085;">→</div>

      <!-- Application Layer -->
      <div style="text-align: center; flex: 1; min-width: 120px;">
        <div style="background: #9B59B6; color: white; padding: 15px; border-radius: 10px; margin-bottom: 10px;">
          <div style="font-size: 2em;">📱</div>
          <div style="font-weight: bold;">Apps</div>
          <div style="font-size: 0.9em;">${app_interfaces.length} interfaces</div>
        </div>
        <div style="font-size: 0.85em; color: #666;">
          ${app_interfaces.slice(0, 2).join(', ')}
        </div>
      </div>
    </div>
  </div>

  <!-- Key Metrics -->
  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-top: 20px;">
    <div style="background: white; padding: 15px; border-radius: 8px; text-align: center;">
      <div style="font-size: 0.85em; color: #666;">Daily Messages</div>
      <div style="font-size: 1.5em; font-weight: bold; color: #16A085;">${arch_metrics.daily_msgs}</div>
    </div>
    <div style="background: white; padding: 15px; border-radius: 8px; text-align: center;">
      <div style="font-size: 0.85em; color: #666;">Daily Data Volume</div>
      <div style="font-size: 1.5em; font-weight: bold; color: #2C3E50;">${arch_metrics.daily_gb} GB</div>
    </div>
    <div style="background: white; padding: 15px; border-radius: 8px; text-align: center;">
      <div style="font-size: 0.85em; color: #666;">Cloud Data (Monthly)</div>
      <div style="font-size: 1.5em; font-weight: bold; color: #3498DB;">${arch_metrics.cloud_monthly_gb} GB</div>
    </div>
    <div style="background: white; padding: 15px; border-radius: 8px; text-align: center;">
      <div style="font-size: 0.85em; color: #666;">Edge Data Reduction</div>
      <div style="font-size: 1.5em; font-weight: bold; color: #E67E22;">${arch_metrics.data_reduction}</div>
    </div>
    <div style="background: white; padding: 15px; border-radius: 8px; text-align: center;">
      <div style="font-size: 0.85em; color: #666;">Sensors per Gateway</div>
      <div style="font-size: 1.5em; font-weight: bold; color: #9B59B6;">${arch_metrics.sensors_per_gateway}</div>
    </div>
    <div style="background: white; padding: 15px; border-radius: 8px; text-align: center;">
      <div style="font-size: 0.85em; color: #666;">Est. Latency</div>
      <div style="font-size: 1.5em; font-weight: bold; color: #E74C3C;">${arch_metrics.total_latency}ms</div>
    </div>
  </div>
</div>
`

---

89.9 Cost Estimation

cost_estimate = {
  // Hardware costs
  let sensor_unit_cost = sensor_types.includes("Camera/Video") ? 50 :
                         sensor_types.includes("GPS/Location") ? 30 :
                         sensor_types.length > 3 ? 20 : 10;
  let sensor_total = sensor_count * sensor_unit_cost;

  let actuator_unit_cost = actuator_types.includes("Motors/Servos") ? 25 :
                           actuator_types.includes("HVAC Controls") ? 40 : 15;
  let actuator_total = actuator_count * actuator_unit_cost;

  let gateway_unit_cost = gateway_needed.includes("Edge server") ? 500 :
                          gateway_needed.includes("Smart") ? 150 :
                          gateway_needed.includes("Simple") ? 50 : 0;
  let gateway_total = gateway_count * gateway_unit_cost;

  let hw_total = sensor_total + actuator_total + gateway_total;

  // Monthly costs
  let cloud_monthly = arch_metrics.cloud_monthly_gb * 0.5; // $0.50 per GB estimate
  cloud_monthly += cloud_services.length * 20; // Base service costs

  let connectivity_monthly = primary_protocol.includes("NB-IoT") || primary_protocol.includes("LTE") ?
                             sensor_count * 1.5 : // Cellular per device
                             primary_protocol.includes("LoRaWAN") ?
                             gateway_count * 50 : // LoRaWAN network server
                             0; // Wi-Fi/local protocols

  let monthly_total = cloud_monthly + connectivity_monthly;

  // Annual costs
  let annual_total = hw_total + (monthly_total * 12);

  return {
    sensor_total: sensor_total,
    actuator_total: actuator_total,
    gateway_total: gateway_total,
    hw_total: hw_total,
    cloud_monthly: cloud_monthly.toFixed(0),
    connectivity_monthly: connectivity_monthly.toFixed(0),
    monthly_total: monthly_total.toFixed(0),
    annual_total: annual_total.toFixed(0),
    cost_per_sensor: (annual_total / sensor_count).toFixed(2)
  };
}

html`
<div style="background: #f8f9fa; padding: 20px; border-radius: 10px; margin: 20px 0;">
  <h4 style="margin-top: 0; color: #2C3E50;">💰 Estimated Costs</h4>

  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px;">

    <!-- One-time costs -->
    <div style="background: white; padding: 20px; border-radius: 8px; border-left: 4px solid #16A085;">
      <h5 style="margin-top: 0; color: #16A085;">Hardware (One-time)</h5>
      <table style="width: 100%; border-collapse: collapse;">
        <tr><td>Sensors (${sensor_count})</td><td style="text-align: right;">$${cost_estimate.sensor_total.toLocaleString()}</td></tr>
        <tr><td>Actuators (${actuator_count})</td><td style="text-align: right;">$${cost_estimate.actuator_total.toLocaleString()}</td></tr>
        <tr><td>Gateways (${gateway_count})</td><td style="text-align: right;">$${cost_estimate.gateway_total.toLocaleString()}</td></tr>
        <tr style="border-top: 2px solid #16A085; font-weight: bold;">
          <td>Total Hardware</td>
          <td style="text-align: right;">$${cost_estimate.hw_total.toLocaleString()}</td>
        </tr>
      </table>
    </div>

    <!-- Recurring costs -->
    <div style="background: white; padding: 20px; border-radius: 8px; border-left: 4px solid #E67E22;">
      <h5 style="margin-top: 0; color: #E67E22;">Monthly Services</h5>
      <table style="width: 100%; border-collapse: collapse;">
        <tr><td>Cloud Services</td><td style="text-align: right;">$${cost_estimate.cloud_monthly}/mo</td></tr>
        <tr><td>Connectivity</td><td style="text-align: right;">$${cost_estimate.connectivity_monthly}/mo</td></tr>
        <tr style="border-top: 2px solid #E67E22; font-weight: bold;">
          <td>Total Monthly</td>
          <td style="text-align: right;">$${cost_estimate.monthly_total}/mo</td>
        </tr>
      </table>
    </div>
  </div>

  <div style="margin-top: 20px; padding: 15px; background: #E8F6F3; border-radius: 8px; display: flex; justify-content: space-around; flex-wrap: wrap; gap: 20px;">
    <div style="text-align: center;">
      <div style="font-size: 0.9em; color: #666;">First Year Total</div>
      <div style="font-size: 1.8em; font-weight: bold; color: #2C3E50;">$${parseInt(cost_estimate.annual_total).toLocaleString()}</div>
    </div>
    <div style="text-align: center;">
      <div style="font-size: 0.9em; color: #666;">Cost per Sensor (Annual)</div>
      <div style="font-size: 1.8em; font-weight: bold; color: #16A085;">$${cost_estimate.cost_per_sensor}</div>
    </div>
  </div>

  <p style="font-size: 0.85em; color: #666; margin-top: 15px; margin-bottom: 0;">
    * Estimates are approximate. Actual costs vary by vendor, region, and specific requirements.
  </p>
</div>
`

---

89.10 Architecture Recommendations

recommendations = {
  let recs = [];
  let warnings = [];

  // Gateway recommendations
  if (gateway_count > 0 && arch_metrics.sensors_per_gateway > 100) {
    warnings.push({
      type: "capacity",
      message: `High sensor density (${arch_metrics.sensors_per_gateway} per gateway). Consider adding more gateways for reliability.`
    });
  }

  if (gateway_needed.includes("No gateway") && sensor_count > 20) {
    warnings.push({
      type: "architecture",
      message: "Direct-to-cloud with many sensors may cause scalability issues. Consider adding a gateway layer."
    });
  }

  // Edge processing recommendations
  if (edge_processing < 20 && data_rate.includes("High") || data_rate.includes("Very High")) {
    recs.push({
      type: "optimization",
      message: "High data rate with low edge processing. Consider increasing edge processing to reduce cloud costs and latency."
    });
  }

  if (latency_requirement.includes("Real-time") && edge_processing < 50) {
    warnings.push({
      type: "latency",
      message: "Real-time latency requirement with cloud-heavy processing may not meet SLA. Increase edge processing."
    });
  }

  // Data retention recommendations
  if (data_retention.includes("3 years") || data_retention.includes("7+")) {
    recs.push({
      type: "storage",
      message: "Long retention period. Implement data tiering: hot (recent), warm (months), cold (archive) storage."
    });
  }

  // Criticality recommendations
  if (arch_criticality.includes("Mission") || arch_criticality.includes("Safety")) {
    recs.push({
      type: "reliability",
      message: "Critical system requires N+1 redundancy for gateways, multi-region cloud, and offline capability."
    });
    if (!edge_tasks.includes("Buffering/store-forward")) {
      warnings.push({
        type: "reliability",
        message: "Critical system should include store-forward buffering for connectivity failures."
      });
    }
  }

  // Protocol-specific recommendations
  if (primary_protocol.includes("LoRaWAN") && data_rate.includes("High")) {
    warnings.push({
      type: "bandwidth",
      message: "LoRaWAN bandwidth may be insufficient for high data rates. Consider Wi-Fi or cellular for high-frequency sensors."
    });
  }

  // Security recommendations
  if (sensor_types.includes("Camera/Video")) {
    recs.push({
      type: "security",
      message: "Video devices require strong encryption, access control, and privacy compliance (GDPR/CCPA)."
    });
  }

  // Cost optimization
  if (cost_estimate.connectivity_monthly > 500) {
    recs.push({
      type: "cost",
      message: "High connectivity costs. Consider LoRaWAN or private network instead of cellular for stationary sensors."
    });
  }

  return { recommendations: recs, warnings: warnings };
}

html`
<div style="margin: 20px 0;">
  ${recommendations.warnings.length > 0 ? html`
    <div style="background: #FADBD8; padding: 20px; border-radius: 10px; margin-bottom: 15px; border-left: 4px solid #E74C3C;">
      <h4 style="margin-top: 0; color: #E74C3C;">⚠️ Warnings</h4>
      <ul style="margin: 0; padding-left: 20px;">
        ${recommendations.warnings.map(w => html`<li style="margin: 8px 0;">${w.message}</li>`)}
      </ul>
    </div>
  ` : ''}

  ${recommendations.recommendations.length > 0 ? html`
    <div style="background: #E8F6F3; padding: 20px; border-radius: 10px; border-left: 4px solid #16A085;">
      <h4 style="margin-top: 0; color: #16A085;">💡 Recommendations</h4>
      <ul style="margin: 0; padding-left: 20px;">
        ${recommendations.recommendations.map(r => html`<li style="margin: 8px 0;">${r.message}</li>`)}
      </ul>
    </div>
  ` : html`
    <div style="background: #D5F4E6; padding: 20px; border-radius: 10px; border-left: 4px solid #27AE60;">
      <h4 style="margin-top: 0; color: #27AE60;">✅ Architecture Looks Good</h4>
      <p style="margin: 0;">Your architecture configuration appears well-balanced for your requirements.</p>
    </div>
  `}
</div>
`

---

89.11 Architecture Patterns

Based on your selections, here are relevant architecture patterns:

TipRecommended Patterns for Your Application

patterns = {
  let applicable = [];

  if (edge_processing >= 50) {
    applicable.push({
      name: "Edge-Heavy Architecture",
      description: "Process most data at the edge, send only insights to cloud",
      pros: ["Low latency", "Reduced bandwidth", "Works offline"],
      cons: ["Edge hardware cost", "Distributed management"],
      learn_more: "../architectures/distributed-specialized/edge-fog-computing.qmd"
    });
  }

  if (gateway_needed.includes("Smart") || gateway_needed.includes("Edge")) {
    applicable.push({
      name: "Gateway-Centric Architecture",
      description: "Gateways aggregate, process, and forward data",
      pros: ["Protocol translation", "Local control", "Security boundary"],
      cons: ["Gateway is single point of failure"],
      learn_more: "../architectures/foundations/gateway-architectures.qmd"
    });
  }

  if (primary_protocol.includes("Zigbee") || primary_protocol.includes("Thread")) {
    applicable.push({
      name: "Mesh Network Architecture",
      description: "Self-healing mesh for resilient sensor networks",
      pros: ["Self-healing", "Extended range", "No single point of failure"],
      cons: ["Latency increases with hops", "Complexity"],
      learn_more: "../networking-and-communications/short-range/zigbee-mesh-and-routing.qmd"
    });
  }

  if (arch_criticality.includes("Mission") || arch_criticality.includes("Safety")) {
    applicable.push({
      name: "High-Availability Architecture",
      description: "Redundant components at every layer",
      pros: ["99.99%+ uptime", "Fault tolerance", "Disaster recovery"],
      cons: ["Higher cost", "Operational complexity"],
      learn_more: "../architectures/foundations/reliability-patterns.qmd"
    });
  }

  if (arch_scale.includes("Regional") || arch_scale.includes("National") || arch_scale.includes("Global")) {
    applicable.push({
      name: "Distributed Cloud Architecture",
      description: "Multi-region deployment with data locality",
      pros: ["Global reach", "Data sovereignty", "Low latency"],
      cons: ["Sync complexity", "Higher cost"],
      learn_more: "../architectures/foundations/cloud-computing.qmd"
    });
  }

  // Default pattern
  if (applicable.length === 0) {
    applicable.push({
      name: "Standard Three-Tier Architecture",
      description: "Sensors → Gateway → Cloud (most common IoT pattern)",
      pros: ["Simple", "Well-documented", "Vendor support"],
      cons: ["Depends on connectivity"],
      learn_more: "../architectures/foundations/iot-reference-models.qmd"
    });
  }

  return applicable;
}

html`
<div style="display: grid; gap: 15px;">
  ${patterns.map(p => html`
    <div style="background: white; padding: 20px; border-radius: 10px; border: 1px solid #ddd; border-left: 4px solid #16A085;">
      <h5 style="margin-top: 0; color: #2C3E50;">${p.name}</h5>
      <p style="color: #666; margin: 10px 0;">${p.description}</p>
      <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-top: 15px;">
        <div>
          <strong style="color: #27AE60;">✓ Advantages:</strong>
          <ul style="margin: 5px 0; padding-left: 18px; font-size: 0.9em;">
            ${p.pros.map(pro => html`<li>${pro}</li>`)}
          </ul>
        </div>
        <div>
          <strong style="color: #E67E22;">⚠ Considerations:</strong>
          <ul style="margin: 5px 0; padding-left: 18px; font-size: 0.9em;">
            ${p.cons.map(con => html`<li>${con}</li>`)}
          </ul>
        </div>
      </div>
    </div>
  `)}
</div>
`

---

89.12 Your Configuration Summary

html`
<div style="background: #f0f4f8; padding: 20px; border-radius: 10px; margin: 20px 0;">
  <h4 style="margin-top: 0; color: #2C3E50;">📋 Architecture Summary</h4>

  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 15px;">
    <div style="background: white; padding: 15px; border-radius: 8px;">
      <strong style="color: #16A085;">Application</strong>
      <p style="margin: 5px 0;">${arch_app}</p>
      <p style="margin: 0; font-size: 0.9em; color: #666;">Scale: ${arch_scale}</p>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <strong style="color: #16A085;">Devices</strong>
      <p style="margin: 5px 0;">${sensor_count} sensors, ${actuator_count} actuators</p>
      <p style="margin: 0; font-size: 0.9em; color: #666;">${sensor_types.join(', ')}</p>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <strong style="color: #16A085;">Connectivity</strong>
      <p style="margin: 5px 0;">${primary_protocol}</p>
      <p style="margin: 0; font-size: 0.9em; color: #666;">${gateway_count} gateways, ${backhaul}</p>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <strong style="color: #16A085;">Processing</strong>
      <p style="margin: 5px 0;">${edge_processing}% edge, ${100-edge_processing}% cloud</p>
      <p style="margin: 0; font-size: 0.9em; color: #666;">${edge_tasks.slice(0, 2).join(', ')}</p>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <strong style="color: #16A085;">Data Profile</strong>
      <p style="margin: 5px 0;">${data_rate}, ${data_size}</p>
      <p style="margin: 0; font-size: 0.9em; color: #666;">Retention: ${data_retention}</p>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <strong style="color: #16A085;">Applications</strong>
      <p style="margin: 5px 0;">${app_interfaces.join(', ')}</p>
      <p style="margin: 0; font-size: 0.9em; color: #666;">Users: ${user_types.join(', ')}</p>
    </div>
  </div>
</div>
`

---

89.13 Next Steps

NoteContinue Your Design Journey

1. Select Protocols: Use the Protocol Selector Wizard to choose specific connectivity
2. Plan Your Learning: Use the Learning Path Generator to create a custom curriculum
3. Explore Simulations: Test your architecture in the Simulation Playground
4. Build a Prototype: Start with our Capstone Projects

89.14 Related Chapters

Topic	Chapter	Description
Reference Models	IoT Reference Models	Standard IoT architecture frameworks
Edge Computing	Edge-Fog Computing	When and how to process at the edge
Cloud Platforms	Cloud Computing	Cloud IoT platform options
Security	Security Architecture	Securing your IoT architecture
Data Management	Data Storage	Database selection for IoT

---

89.15 Summary

The IoT Architecture Planner helps you design complete IoT systems:

• 5-layer design covering sensing, network, processing, cloud, and application
• Data volume estimation based on sensors, frequency, and message size
• Cost projection for hardware and ongoing services
• Edge vs. cloud trade-offs with automatic recommendations
• Pattern matching to relevant architecture approaches

TipKey Architecture Principles

1. Start small, scale up - Begin with proven patterns, add complexity as needed
2. Design for failure - Assume components will fail; build redundancy
3. Secure by design - Security is not an afterthought
4. Optimize data flow - Process at the edge when possible to reduce costs
5. Plan for evolution - Requirements change; choose flexible architectures