1317  Serialization Scenarios and Bandwidth Analysis

Match Serialization Formats to IoT Use Cases and Calculate Costs

1317.1 Learning Objectives

By the end of this section, you will be able to:

• Match serialization formats to specific IoT deployment scenarios
• Calculate bandwidth costs for different format choices at scale
• Design custom message structures and analyze their serialization efficiency
• Apply format-specific best practices for common IoT use cases

1317.2 Introduction

Different IoT scenarios have vastly different constraints. A battery-powered LoRa sensor has different needs than a factory MQTT gateway. This chapter helps you match the right serialization format to your specific use case and quantify the bandwidth and cost implications.

1317.3 IoT Scenario Analysis

ieeeColors = ({
  navy: "#2C3E50",
  teal: "#16A085",
  orange: "#E67E22",
  gray: "#7F8C8D",
  red: "#E74C3C",
  green: "#27AE60",
  purple: "#8E44AD",
  blue: "#3498DB",
  yellow: "#F1C40F",
  darkGray: "#34495E",
  lightGray: "#ECF0F1"
})

// Format definitions for reference
formats = [
  { id: "json", name: "JSON", color: ieeeColors.orange, overhead: 1.0 },
  { id: "msgpack", name: "MessagePack", color: ieeeColors.teal, overhead: 0.6 },
  { id: "protobuf", name: "Protocol Buffers", color: ieeeColors.blue, overhead: 0.4 },
  { id: "cbor", name: "CBOR", color: ieeeColors.purple, overhead: 0.55 },
  { id: "avro", name: "Apache Avro", color: ieeeColors.green, overhead: 0.45 },
  { id: "binary", name: "Raw Binary", color: ieeeColors.red, overhead: 0.25 }
]

// IoT Scenarios
scenarios = [
  {
    name: "LoRa/NB-IoT Constrained",
    description: "Battery-powered sensors with limited bandwidth",
    constraints: { bandwidth: "Very Low", processing: "Low", battery: "Critical" },
    recommended: ["binary", "cbor", "protobuf"],
    avoid: ["json"],
    reason: "Every byte counts; schema-based formats enable smallest payloads"
  },
  {
    name: "Industrial MQTT",
    description: "Factory sensors publishing to MQTT broker",
    constraints: { bandwidth: "Medium", processing: "Medium", battery: "N/A" },
    recommended: ["msgpack", "protobuf", "cbor"],
    avoid: [],
    reason: "Balance of efficiency and debugging capability"
  },
  {
    name: "Cloud API Integration",
    description: "Devices communicating with REST APIs",
    constraints: { bandwidth: "High", processing: "High", battery: "Medium" },
    recommended: ["json", "msgpack"],
    avoid: ["binary"],
    reason: "Compatibility with web infrastructure; debugging ease"
  },
  {
    name: "Edge Analytics",
    description: "Local processing before cloud upload",
    constraints: { bandwidth: "Variable", processing: "High", battery: "Medium" },
    recommended: ["avro", "protobuf", "msgpack"],
    avoid: ["json"],
    reason: "Schema evolution for data pipelines; efficient storage"
  },
  {
    name: "Real-time Telemetry",
    description: "High-frequency sensor streams",
    constraints: { bandwidth: "High", processing: "Critical", battery: "N/A" },
    recommended: ["protobuf", "binary", "msgpack"],
    avoid: ["json", "avro"],
    reason: "Fastest encode/decode for high throughput"
  },
  {
    name: "Device Configuration",
    description: "Sending settings to devices",
    constraints: { bandwidth: "Low", processing: "Low", battery: "Low" },
    recommended: ["json", "cbor"],
    avoid: ["binary"],
    reason: "Human readability for debugging; flexibility for schema changes"
  }
]

html`
<div style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;">

  <div style="display: grid; gap: 15px;">
    ${scenarios.map(s => html`
      <div style="background: white; border: 1px solid ${ieeeColors.gray}30; border-radius: 12px; overflow: hidden;">
        <div style="background: ${ieeeColors.navy}; color: white; padding: 15px; display: flex; justify-content: space-between; align-items: center;">
          <div>
            <div style="font-weight: bold; font-size: 16px;">${s.name}</div>
            <div style="font-size: 12px; opacity: 0.8;">${s.description}</div>
          </div>
          <div style="display: flex; gap: 10px;">
            ${s.recommended.slice(0, 2).map(r => {
              const format = formats.find(f => f.id === r);
              return html`<span style="background: ${format?.color || ieeeColors.gray}; padding: 4px 12px; border-radius: 20px; font-size: 12px;">${format?.name || r}</span>`;
            })}
          </div>
        </div>

        <div style="padding: 15px;">
          <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 15px; margin-bottom: 15px;">
            <div style="text-align: center;">
              <div style="font-size: 11px; color: ${ieeeColors.gray};">Bandwidth</div>
              <div style="font-weight: bold; color: ${s.constraints.bandwidth === 'Very Low' ? ieeeColors.red : s.constraints.bandwidth === 'Low' ? ieeeColors.orange : ieeeColors.green};">${s.constraints.bandwidth}</div>
            </div>
            <div style="text-align: center;">
              <div style="font-size: 11px; color: ${ieeeColors.gray};">Processing</div>
              <div style="font-weight: bold; color: ${s.constraints.processing === 'Critical' ? ieeeColors.red : s.constraints.processing === 'Low' ? ieeeColors.orange : ieeeColors.green};">${s.constraints.processing}</div>
            </div>
            <div style="text-align: center;">
              <div style="font-size: 11px; color: ${ieeeColors.gray};">Battery</div>
              <div style="font-weight: bold; color: ${s.constraints.battery === 'Critical' ? ieeeColors.red : s.constraints.battery === 'N/A' ? ieeeColors.gray : ieeeColors.green};">${s.constraints.battery}</div>
            </div>
          </div>

          <div style="background: ${ieeeColors.teal}10; padding: 10px; border-radius: 6px; border-left: 3px solid ${ieeeColors.teal};">
            <div style="font-size: 12px; color: ${ieeeColors.darkGray};">${s.reason}</div>
          </div>

          ${s.avoid.length > 0 ? html`
            <div style="margin-top: 10px; font-size: 11px; color: ${ieeeColors.red};">
              <strong>Avoid:</strong> ${s.avoid.map(a => formats.find(f => f.id === a)?.name || a).join(', ')}
            </div>
          ` : ''}
        </div>
      </div>
    `)}
  </div>

</div>
`

(a)

(b)

(c)

(d)

Figure 1317.1: Serialization format recommendations for common IoT scenarios

1317.4 Bandwidth Impact Calculator

Use this calculator to estimate the real-world cost implications of your serialization format choice across your entire IoT deployment.

baseMessageSize = 100 // bytes for JSON baseline

viewof deviceCount = Inputs.range([1, 10000], {
  label: "Number of Devices",
  step: 1,
  value: 1000
})

viewof messagesPerHour = Inputs.range([1, 3600], {
  label: "Messages per Hour per Device",
  step: 1,
  value: 60
})

viewof costPerMB = Inputs.range([0, 1], {
  label: "Cost per MB ($)",
  step: 0.01,
  value: 0.10
})

bandwidthAnalysis = {
  const messagesPerMonth = deviceCount * messagesPerHour * 24 * 30;

  return formats.map(f => {
    const size = Math.round(baseMessageSize * f.overhead);
    const monthlyBytes = messagesPerMonth * size;
    const monthlyMB = monthlyBytes / (1024 * 1024);
    const monthlyCost = monthlyMB * costPerMB;
    const savings = (baseMessageSize - size) * messagesPerMonth / (1024 * 1024) * costPerMB;

    return {
      format: f,
      size: size,
      monthlyMB: monthlyMB.toFixed(2),
      monthlyGB: (monthlyMB / 1024).toFixed(3),
      monthlyCost: monthlyCost.toFixed(2),
      savings: savings.toFixed(2),
      messagesPerMonth: messagesPerMonth.toLocaleString()
    };
  }).sort((a, b) => a.size - b.size);
}

html`
<div style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;">

  <div style="background: ${ieeeColors.navy}10; border-radius: 12px; padding: 20px; margin-bottom: 20px;">
    <div style="text-align: center; margin-bottom: 15px;">
      <div style="font-size: 14px; color: ${ieeeColors.gray};">Monthly Messages</div>
      <div style="font-size: 28px; font-weight: bold; color: ${ieeeColors.navy};">${bandwidthAnalysis[0]?.messagesPerMonth}</div>
      <div style="font-size: 12px; color: ${ieeeColors.gray};">${deviceCount.toLocaleString()} devices x ${messagesPerHour}/hr x 720 hours</div>
    </div>
  </div>

  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 15px; margin-bottom: 20px;">
    ${bandwidthAnalysis.map(b => html`
      <div style="background: white; border: 2px solid ${b.format.color}; border-radius: 12px; padding: 15px; text-align: center;">
        <div style="font-weight: bold; color: ${b.format.color}; margin-bottom: 10px;">${b.format.name}</div>
        <div style="font-size: 24px; font-weight: bold; color: ${ieeeColors.navy};">${b.monthlyGB} GB</div>
        <div style="font-size: 12px; color: ${ieeeColors.gray};">per month</div>
        <div style="margin-top: 10px; padding-top: 10px; border-top: 1px solid ${ieeeColors.lightGray};">
          <div style="font-size: 18px; font-weight: bold; color: ${parseFloat(b.savings) > 0 ? ieeeColors.green : ieeeColors.gray};">
            ${parseFloat(b.savings) > 0 ? `$${b.savings}` : '$0.00'}
          </div>
          <div style="font-size: 11px; color: ${ieeeColors.gray};">monthly savings</div>
        </div>
      </div>
    `)}
  </div>

  <div style="background: ${ieeeColors.green}10; border: 2px solid ${ieeeColors.green}; border-radius: 12px; padding: 20px; text-align: center;">
    <div style="font-size: 14px; color: ${ieeeColors.gray};">Best Savings: Switch from JSON to ${bandwidthAnalysis[0]?.format.name}</div>
    <div style="font-size: 32px; font-weight: bold; color: ${ieeeColors.green}; margin: 10px 0;">
      $${bandwidthAnalysis[0]?.savings}/month
    </div>
    <div style="font-size: 12px; color: ${ieeeColors.gray};">
      ${((1 - bandwidthAnalysis[0]?.format.overhead) * 100).toFixed(0)}% size reduction =
      ${(parseFloat(bandwidthAnalysis[bandwidthAnalysis.length - 1]?.monthlyGB || 0) - parseFloat(bandwidthAnalysis[0]?.monthlyGB || 0)).toFixed(2)} GB/month saved
    </div>
  </div>

</div>
`

(a)

(b)

(c)

(d)

(e)

(f)

Figure 1317.2: Calculate bandwidth savings from serialization format choice

1317.5 Custom Field Editor

Test how your specific message structure affects serialization efficiency across different formats.

viewof customFields = Inputs.form({
  field1_name: Inputs.text({ label: "Field 1 Name", value: "sensorId" }),
  field1_type: Inputs.select(["string", "int", "float", "bool"], { label: "Type", value: "string" }),
  field1_value: Inputs.text({ label: "Value", value: "temp-01" }),
  field2_name: Inputs.text({ label: "Field 2 Name", value: "reading" }),
  field2_type: Inputs.select(["string", "int", "float", "bool"], { label: "Type", value: "float" }),
  field2_value: Inputs.text({ label: "Value", value: "25.5" }),
  field3_name: Inputs.text({ label: "Field 3 Name", value: "status" }),
  field3_type: Inputs.select(["string", "int", "float", "bool"], { label: "Type", value: "int" }),
  field3_value: Inputs.text({ label: "Value", value: "1" })
})

customMessageSizes = {
  const fields = [
    { name: customFields.field1_name, type: customFields.field1_type, value: customFields.field1_value },
    { name: customFields.field2_name, type: customFields.field2_type, value: parseFloat(customFields.field2_value) || customFields.field2_value },
    { name: customFields.field3_name, type: customFields.field3_type, value: parseInt(customFields.field3_value) || customFields.field3_value }
  ].filter(f => f.name.trim() !== '');

  const message = {};
  fields.forEach(f => {
    let value = f.value;
    if (f.type === "int") value = parseInt(f.value) || 0;
    else if (f.type === "float") value = parseFloat(f.value) || 0;
    else if (f.type === "bool") value = f.value === "true" || f.value === "1";
    message[f.name] = value;
  });

  const jsonSize = JSON.stringify(message).length;

  return formats.map(format => {
    let size = jsonSize;
    switch (format.id) {
      case "json": size = jsonSize; break;
      case "msgpack": size = Math.ceil(jsonSize * 0.6); break;
      case "protobuf": size = Math.ceil(jsonSize * 0.4); break;
      case "cbor": size = Math.ceil(jsonSize * 0.55); break;
      case "avro": size = Math.ceil(jsonSize * 0.45); break;
      case "binary": size = Math.ceil(jsonSize * 0.25); break;
    }
    return { format, size };
  }).sort((a, b) => a.size - b.size);
}

html`
<div style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;">
  <h4 style="color: ${ieeeColors.navy};">Custom Message Size Analysis</h4>

  <div style="background: ${ieeeColors.darkGray}; color: white; padding: 15px; border-radius: 8px; margin-bottom: 15px; font-family: 'Courier New', monospace; font-size: 12px;">
    <div style="color: ${ieeeColors.teal}; margin-bottom: 5px;">// Your custom message:</div>
    <pre style="margin: 0;">${JSON.stringify(
      Object.fromEntries([
        [customFields.field1_name, customFields.field1_type === "int" ? parseInt(customFields.field1_value) : customFields.field1_type === "float" ? parseFloat(customFields.field1_value) : customFields.field1_value],
        [customFields.field2_name, customFields.field2_type === "int" ? parseInt(customFields.field2_value) : customFields.field2_type === "float" ? parseFloat(customFields.field2_value) : customFields.field2_value],
        [customFields.field3_name, customFields.field3_type === "int" ? parseInt(customFields.field3_value) : customFields.field3_type === "float" ? parseFloat(customFields.field3_value) : customFields.field3_value]
      ].filter(([k]) => k.trim() !== '')),
      null, 2
    )}</pre>
  </div>

  <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px;">
    ${customMessageSizes.slice(0, 3).map((item, i) => html`
      <div style="background: ${i === 0 ? ieeeColors.green + '20' : 'white'}; border: 2px solid ${item.format.color}; border-radius: 8px; padding: 15px; text-align: center;">
        <div style="font-size: 12px; color: ${item.format.color}; font-weight: bold;">${i === 0 ? 'Best: ' : ''}${item.format.name}</div>
        <div style="font-size: 24px; font-weight: bold; color: ${ieeeColors.navy}; margin-top: 5px;">${item.size} B</div>
      </div>
    `)}
  </div>
</div>
`

(a)

(b)

(c)

Figure 1317.3: Create custom IoT message structures to test serialization

1317.6 Format Deep Dives

TipJSON - Universal but Verbose

Best for: Debugging, configuration files, REST APIs

{"deviceId":"sens-001","temperature":23.5,"timestamp":1704067200}

• Human-readable text format
• Self-describing (field names included)
• Native browser/JavaScript support
• Largest payload size (baseline)

IoT Consideration: Use when debugging ease outweighs bandwidth concerns, or for device configuration where human editing is needed.

TipMessagePack - Binary JSON

Best for: General IoT messaging, MQTT payloads

MessagePack achieves ~40% size reduction by:

• Using binary type markers instead of JSON syntax
• Storing small integers in 1 byte
• Eliminating quotation marks and colons

IoT Consideration: Drop-in replacement for JSON with significant size savings. Excellent balance of efficiency and flexibility.

TipProtocol Buffers - Maximum Efficiency

Best for: High-throughput systems, typed APIs

Protocol Buffers achieve ~60% size reduction through:

• Schema-based field numbering (no field names in payload)
• Variable-length integer encoding (varints)
• Optional/repeated field optimization

message SensorReading {
  string device_id = 1;
  float temperature = 2;
  int64 timestamp = 3;
}

IoT Consideration: Best choice when you control both sender and receiver, and schema management is acceptable.

TipCBOR - IoT Native

Best for: CoAP-based systems, constrained devices

CBOR was designed specifically for IoT:

• IETF RFC 8949 standard
• Native CoAP content type
• Supports binary data efficiently
• Designed for constrained environments

IoT Consideration: First choice for CoAP deployments and standards-based IoT implementations.

WarningRaw Binary - Use With Caution

Best for: Extremely constrained devices, fixed-format telemetry

Raw binary provides smallest payloads but:

• No built-in type safety
• Schema changes break compatibility
• Debugging is difficult
• Endianness must be managed manually

IoT Consideration: Only use when every byte matters (LoRa, satellite) AND message format will never change.

1317.7 Scenario Selection Guide

NoteQuick Decision Guide by Scenario

Scenario	Primary Choice	Alternative	Avoid
LoRa/Sigfox	Raw Binary	CBOR	JSON
NB-IoT	CBOR	Protobuf	JSON
Industrial MQTT	MessagePack	Protobuf	-
REST APIs	JSON	MessagePack	Binary
High-frequency streams	Protobuf	Binary	JSON, Avro
Edge buffering	Avro	Protobuf	JSON
Device config	JSON	CBOR	Binary
CoAP systems	CBOR	-	JSON

1317.8 Summary

NoteKey Takeaways

1. Match format to constraints - Every scenario has different bandwidth, processing, and battery requirements
2. Bandwidth costs add up - At scale, a 60% size reduction translates to significant cost savings
3. Custom messages vary - Test your actual message structure to see real-world size differences
4. Format features matter - Schema requirements, human readability, and IoT suitability influence the choice
5. Don’t over-optimize - JSON is fine when debugging ease matters more than bandwidth

1317.9 What’s Next

Continue exploring serialization analysis with:

• Serialization Format Basics - Interactive comparator and feature matrix
• Advanced Serialization Analysis - Trade-off matrices, network simulation, and schema evolution
• IoT Data Formats - Overview of data representation in IoT