IoT Fundamentals · Study deck
Packet Protocol Overhead
Picture a battery sensor sending a two-byte value every minute.
Physics Phoebe is your guide for this deck.
After studying this chapter
Learning objectives
You will be able to:
- Explain: If the node sends eight readings together, the useful payload becomes 64 bytes while the same UDP/IPv4 header is still 28 bytes, so the share rises to about 70 percent before link framing.
- Explain: Each link has a maximum frame size, and a payload larger than the link's maximum transmission unit must be fragmented, which adds headers and increases the chance that a loss forces a resend.
- Explain: The cost is latency, because the device waits to fill the batch, and risk, because losing one packet now loses N readings instead of one.
Major section
In 60 Seconds
Addresses, checks, wrappers, replies, and retries may cost far more than the value itself.
- JSON means JavaScript Object Notation, a readable text format for named data.
- A payload means the useful reading or command inside a message.
- A protocol means the shared rules for a message exchange.
Major section
In 60 Seconds (continued)
This runway does not prove that batching or a compact format is always better.
- The deeper sections explain wrapping layers, payload share, byte budgets, timing, reliability, and the trade between fewer packets and fresher data.
- Protocol overhead is mostly fixed per packet, so it barely matters for large transfers but dominates the tiny messages that constrained IoT devices send.
- Understanding the byte budget is what separates an efficient sensor fleet from one that wastes most of its airtime and energy on packaging.
Major section
The Packaging Can Outweigh the Contents
The packaging and paperwork can easily weigh more than the key itself.
- A network packet is the same: the payload is the key, and the headers are the box, the labels, and the tracking.
- The important idea is that overhead is roughly constant per packet.
- That improvement is not compression; it is fixed-cost amortization.
Major section
The Packaging Can Outweigh the Contents (continued)
For a large shipment the packaging is a rounding error, but for one tiny item it is most of what you pay to send.
- If you only need the intuition, this layer is enough: each packet has fixed overhead for addressing, framing, and control.
- A payload share of ninety percent means the network is mostly carrying your data.
- A payload share of twenty percent means you are mostly paying to move headers.
Major section
The Packaging Can Outweigh the Contents (continued)
If the node sends eight readings together, the useful payload becomes 64 bytes while the same UDP/IPv4 header is still 28 bytes, so the share rises to about 70 percent before link framing.
- The limit is freshness and frame size: a leak alarm may need immediate delivery, while a routine hourly total can wait and batch safely.
- Small payloads pay the most When the payload is tiny, the fixed header can be larger than the data itself, wasting bandwidth and energy.
- A sensor sending a 4-byte reading can spend far more bytes on headers than on the reading itself.
Major section
Apply It: Add Up the Byte Budget
Seventy percent of the transmitted bytes are packaging.
- A byte-budget review lists the protocol layers wrapped around your payload, sums their headers, and computes the payload share.
- If the share is low, you change the design before you scale the fleet, not after.
- The fixed header was paid once instead of ten times.
Major section
Apply It: Add Up the Byte Budget (continued)
Encapsulation: Headers Stack Up The payload is wrapped layer by layer, and each layer adds its own header.
- The sizes below are the defining minimum header sizes for these named protocols; options and addresses can make some of them larger.
- Worked Example: A 12-Byte Reading Over UDP/IPv4 A node sends a 12-byte reading as a UDP datagram over IPv4.
- The arithmetic is small enough to audit directly.
Major section
Apply It: Add Up the Byte Budget (continued)
Improving the Budget Batch readings Combine several samples into one packet so the per-packet header is amortized across more data.
- The transport and network headers alone are 8 + 20 = 28 bytes, before any link framing.
- payload = 12 bytes header = 8 (UDP) + 20 (IPv4) = 28 bytes total = 12 + 28 = 40 bytes payload share = 12 / 40 = 30%.
- If you can total a byte budget and pick an action, you can stop here.
Major section
Under the Hood: Efficiency Math and Link Limits
Hidden headers make the real budget worse than expected.
- The payload-share rule comes from a simple ratio, and the batching trade-off comes from amortizing a fixed cost.
- This single ratio explains why the same network feels efficient for downloads and wasteful for one-line sensor messages.
- Fragmentation adds overhead and resend risk.
Major section
Under the Hood: Efficiency Math and Link Limits (continued)
As N grows, the single H is spread thinner and efficiency climbs.
- The cost is latency, because the device waits to fill the batch, and risk, because losing one packet now loses N readings instead of one.
- Batch size is therefore a deliberate trade among efficiency, freshness, and loss exposure.
- The Link Frame Sets a Ceiling You cannot batch without limit.
- At this depth, overhead is a budget problem with a hard ceiling.
Major section
Under the Hood: Efficiency Math and Link Limits (continued)
Each link has a maximum frame size, and a payload larger than the link's maximum transmission unit must be fragmented, which adds headers and increases the chance that a loss forces a resend.
- On a classic Ethernet link the data payload limit is 1500 bytes; on a constrained radio it is far smaller.
- Shrinking an already tiny payload.: Below a point, compacting the payload makes the overhead share worse, not better; batch instead.
- Batching past the frame limit.: A batch larger than the link MTU is fragmented, which reintroduces overhead and adds loss risk.
Major section
Summary
Because overhead is roughly fixed per packet, small IoT payloads suffer proportionally more overhead than large transfers.
- Every packet carries fixed overhead for addressing, framing, and control, plus the useful payload.
- Payload share, P divided by P plus H, measures how much of the transmitted data is actually useful.
- Headers stack through encapsulation: application, transport, network, and link each add their own bytes, and link layers may add a trailer too.
Deck summary
Key takeaways
Addresses, checks, wrappers, replies, and retries may cost far more than the value itself.
- This runway does not prove that batching or a compact format is always better.
- The packaging and paperwork can easily weigh more than the key itself.
- For a large shipment the packaging is a rounding error, but for one tiny item it is most of what you pay to send.
- If the node sends eight readings together, the useful payload becomes 64 bytes while the same UDP/IPv4 header is still 28 bytes, so the share rises to about 70 percent before link framing.
Retrieval practice
Recall check 1 of 3
Physics Phoebe says: answer from memory, then check your reasoning.
Q1Why does protocol overhead hurt small IoT messages much more than large file transfers?
Show answer
Answer: A The same fixed header is a big proportion of a small message and a negligible proportion of a large one.
Retrieval practice
Recall check 2 of 3
Physics Phoebe says: answer from memory, then check your reasoning.
Q2A constrained node sends one 8-byte reading per packet, and most of each packet is header. Which change most improves byte efficiency without losing data?
Show answer
Answer: C Batching amortizes the fixed header across more payload, which directly raises the payload share.
Retrieval practice
Recall check 3 of 3
Physics Phoebe says: answer from memory, then check your reasoning.
Q3A node sends a 12-byte reading in a UDP/IPv4 datagram with 28 bytes of header. Roughly what fraction of the transmitted bytes is useful payload?
Show answer
Answer: A Efficiency is 12 / (12 + 28) = 12 / 40 = 0.30, so about 30 percent is payload.
Print reference
Answers
Answer key.
- A · The same fixed header is a big proportion of a small message and a negligible proportion of a large one.
- C · Batching amortizes the fixed header across more payload, which directly raises the payload share.
- A · Efficiency is 12 / (12 + 28) = 12 / 40 = 0.30, so about 30 percent is payload.