Splitting a subnet into equal blocks without the guesswork

Dividing a subnet into equal blocks is one of the most common tasks in network planning, yet it remains a source of errors for many engineers. Whether you are allocating space for multiple departments, designing a multi-site deployment, or preparing for a certification exam, the ability to split a parent subnet into equal child subnets quickly and accurately is essential. This guide walks you through the method so you can eliminate guesswork and get it right every time.

Why equal blocks matter

Equal-sized subnets simplify routing, reduce address waste, and make network documentation predictable. When you divide a parent subnet into n equal blocks, each child subnet has the same number of usable host addresses, which makes capacity planning, DHCP pool sizing, and firewall rule documentation straightforward. Unequal divisions work too, but they require more careful bookkeeping and leave room for mistakes.

The core formula

Here is the step-by-step process: 1. Identify your parent subnet (for example, 10.0.0.0/22). 2. Decide how many equal blocks you need (for example, 4). 3. Find the smallest power of 2 that is greater than or equal to your block count. Powers of 2 are 1, 2, 4, 8, 16, 32, and so on. 4. Count how many bits that power represents. For example, 4 = 2^2, so you need 2 bits. 5. Add that bit count to the parent prefix length. For example, /22 + 2 = /24. 6. Your child subnets all use /24, and you will have exactly 4 of them. The child prefix length is always: parent prefix + log2(number of blocks).

Example: Divide 10.0.0.0/22 into 4 equal blocks

Parent: 10.0.0.0/22 (1024 total addresses, 1 block)
Number of blocks needed: 4
Power of 2: 4 = 2^2, so borrow 2 bits
Child prefix: /22 + 2 = /24

Result:
  Block 1: 10.0.0.0/24   (256 addresses)
  Block 2: 10.0.1.0/24   (256 addresses)
  Block 3: 10.0.2.0/24   (256 addresses)
  Block 4: 10.0.3.0/24   (256 addresses)

Common pitfalls

• →Forgetting to round up to the next power of 2. If you need 5 blocks, you must use 8 (2^3), not 5. This means 3 blocks will be unused but reserved.
• →Confusing the number of bits to borrow with the number of blocks. Borrowing 2 bits gives 4 blocks, not 2.
• →Mixing prefix length with host count. A /24 has 256 total addresses, 254 usable (after network and broadcast), but the subnet math uses the total.
• →Assuming IPv6 works differently. The same logic applies: borrow bits equal to log2(block count) and add to the parent prefix.

Real-world example

Suppose you manage a company network and need to allocate space for 6 regional offices from a parent block of 172.16.0.0/20. You want each office to have an equal-sized subnet. Step 1: Parent is /20. Step 2: You need 6 blocks. Step 3: The smallest power of 2 >= 6 is 8 (2^3). Step 4: You borrow 3 bits. Step 5: Child prefix = /20 + 3 = /23. Each regional office gets a /23 (512 total addresses per subnet). You will have 8 subnets total, so 2 are left for future growth.

172.16.0.0/23   - Region 1
172.16.2.0/23   - Region 2
172.16.4.0/23   - Region 3
172.16.6.0/23   - Region 4
172.16.8.0/23   - Region 5
172.16.10.0/23  - Region 6
172.16.12.0/23  - Reserved
172.16.14.0/23  - Reserved

Verification

Always verify your work by checking that each child subnet occupies exactly one block in the binary address space and that they do not overlap. The easiest way is to confirm that the number of subnets you created matches 2^(bits borrowed), and that the increment between network addresses equals 2^(32 - child prefix length) in decimal.