subnetting my coffee shop

TL;DR

Host-based subnetting begins with the required number of IP addresses per subnet, then selects the smallest power of two that can contain that many addresses.

Briefing Cornell Notes

Briefing

Subnetting flips from “how many networks do we need?” to “how many usable IPs does each network need?”—and that change drives the entire math. In the coffee shop scenario, each location needs roughly 40 IP addresses (to cover 5 employees, 1 server, 2 Raspberry Pi devices, 2 wireless access points, and up to 20 guests, with extra room). Starting from 10.1.1.0/24, the task is to carve the /24 into three subnets sized for that host requirement, not just split it evenly.

The method hinges on the subnet mask. Convert the existing mask (255.255.255.0) into binary, then use a “Nora two” chart (a doubling table) to find how many host bits are required. For 40 addresses per coffee shop, the smallest power of two that fits is 64 (since 32 is too small). Reaching 64 means reserving 6 host bits. The key difference from subnetting by network count comes in the “upside down” step: instead of taking host bits away from the left, the process reserves the host bits on the right and lets the remaining bits become network bits. With 6 host bits reserved, the increment (the size of each subnet) is determined by the last network bit—64—so each subnet advances by 64 in the final octet.

That produces three subnets from the original /24: 10.1.1.0–10.1.1.63, 10.1.1.64–10.1.1.127, and 10.1.1.128–10.1.1.191. Each subnet has 64 total addresses, but network and broadcast addresses are reserved, leaving 62 usable IPs—enough for the ~40 needed per shop. The final subnet mask becomes /26 (because 26 network bits remain after reserving 6 host bits). In dotted decimal, the mask is 255.255.255.192, derived by adding the active bits (128 + 64 = 192) in the last octet.

A second example applies the same “host-first” logic to an ISP-style allocation. Starting with 142.0.0.0/16, five customers each need at least 20 public IPs, so the smallest power of two that fits is 32. That requires 5 host bits. Using the upside-down reservation approach again, the increment becomes 32, yielding customer subnets that step through the address space in blocks of 32 within the relevant octet. Converting the resulting binary mask back to dotted decimal gives /27 (255.255.255.224), and each subnet provides 30 usable addresses—meeting the 20-IP requirement while leaving room for growth through additional subnets.

The takeaway is practical: host-based subnetting is nearly identical to network-based subnetting except for one crucial inversion—reserve the host bits first, then compute the increment and subnet ranges. Once that’s mastered, problems that look “backwards,” like determining broadcast addresses from a host IP and prefix, become solvable through the same reverse-engineering mindset.

Cornell Notes

Host-based subnetting starts with the number of IP addresses each subnet must support, then derives the subnet mask and subnet ranges from that requirement. For 40 addresses per coffee shop, the smallest power of two that fits is 64, which corresponds to 6 host bits. The “upside down” step reserves those 6 host bits on the right, turning the remaining bits into network bits; this yields a /26 mask (255.255.255.192) and an increment of 64. From 10.1.1.0/24, the three resulting subnets are 10.1.1.0/26, 10.1.1.64/26, and 10.1.1.128/26, each with 62 usable addresses. The same approach works for ISP allocations, such as 142.0.0.0/16 split into /27 subnets for 20+ public IPs per customer.

How does host-based subnetting change the workflow compared with subnetting by number of subnets?

Both approaches revolve around the subnet mask, but host-based subnetting starts by sizing for hosts. After converting the original mask to binary, the process uses a doubling chart to find the smallest power of two that can hold the required number of addresses (including network and broadcast). The crucial inversion is the “upside down” step: instead of removing host bits from the left, it reserves the host bits on the right and lets the remaining bits become network bits. That reservation determines the new prefix length and the increment used to build subnet ranges.

Why does the coffee shop example use 64 addresses when the requirement is 40?

Because IP address counts in a subnet follow powers of two. The smallest power of two that is at least 40 is 64. The method checks 32 first (too small), then selects 64. That choice implies 6 host bits (since 2^6 = 64). Even though only 40 are “needed,” the subnet must be large enough to provide the required usable space after reserving network and broadcast addresses.

What does “reserve the host bits” mean in practice, and how does it affect the subnet mask?

In the binary subnet mask, host bits are the zeros portion that determines how many addresses exist per subnet. Reserving the host bits means keeping those rightmost bits as host bits and converting everything else into network bits. In the coffee shop case, reserving 6 host bits leaves 26 network bits from the original /24 context after the mask is rebuilt, producing a /26 prefix. That’s why the final mask becomes 255.255.255.192.

How is the increment determined, and how does it produce the subnet ranges?

The increment equals the value of the last network bit in the new subnet mask. For the coffee shops, the last network bit corresponds to 64, so subnet boundaries advance by 64 in the final octet. Starting at 10.1.1.0, the ranges become 0–63, 64–127, and 128–191. Each range matches the /26 block size and yields 64 total addresses per subnet.

How do you compute usable addresses once the subnet size is known?

Usable addresses exclude the network address (first) and broadcast address (last). So if a subnet contains 64 total addresses, usable hosts are 64 − 2 = 62. In the coffee shop example, that’s why each /26 subnet supports 62 usable IPs, comfortably covering the ~40-IP requirement.

In the ISP example (142.0.0.0/16), why does the solution end up using /27?

Each customer needs at least 20 public IPs, so the smallest power of two that fits is 32 (2^5). That means 5 host bits. Reserving 5 host bits leaves 27 network bits, producing a /27 mask. The increment then becomes 32, and each /27 subnet provides 32 total addresses, or 30 usable addresses (32 − 2), which satisfies the 20-IP requirement while allowing additional subnets for more customers.

Review Questions

Given a starting network of X.Y.Z.0/24 and a requirement of 50 usable IPs per subnet, what power of two should be selected for total addresses, and how many host bits does that imply?
For a subnet mask of /26, what are the increment value and the usable host count per subnet?
If a host IP is provided with a prefix length, how can you reverse-engineer the subnet’s broadcast address using the increment concept?

Key Points

1
Host-based subnetting begins with the required number of IP addresses per subnet, then selects the smallest power of two that can contain that many addresses.
2
Convert the existing subnet mask to binary so the new prefix length can be derived from host-bit reservation.
3
Use a doubling chart (the “Nora two” approach) to map required address capacity to the number of host bits (e.g., 40 → 64 → 6 host bits).
4
The “upside down” step reserves host bits on the right, turning the remaining bits into network bits and producing the new subnet mask.
5
Compute the increment from the last network bit; use that increment to generate subnet ranges (e.g., /26 → increment 64).
6
Always subtract 2 from the total addresses in a subnet to get usable host IPs (network and broadcast are reserved).
7
The same host-first method applies to ISP customer allocations: pick the smallest power of two ≥ required IPs, reserve host bits, then build /prefix subnets with the correct increment.

Highlights

40 required addresses becomes 64 total addresses, which means 6 host bits and a /26 subnet mask.

Reserving host bits on the right (the “upside down” step) is the core inversion that distinguishes host-based from network-based subnetting.

From 10.1.1.0/24, an increment of 64 yields exactly three /26 subnets: 10.1.1.0/26, 10.1.1.64/26, and 10.1.1.128/26.

A /27 subnet provides 30 usable addresses because 32 total addresses minus network and broadcast equals 30.

Topics

Host-Based Subnetting
Subnet Mask Calculation
Increment and Subnet Ranges
Binary Prefix Math
ISP Address Allocation