IP Addresses and Subnets for Absolute Beginners

Imagine you live at apartment 14. There are a thousand apartment 14s in your city — yours is findable only because the rest of your address narrows it down first: the building, the street, the zip code. The mail carrier finds your building before ever looking for your door.

Every device on a network has the same problem. Its number is only meaningful inside its own "building," and the network needs a way to know which building to deliver to before it hunts for the door. Get this wrong in a real data center and a server's messages walk down the wrong hallway — silent, maddening failures that eat whole afternoons.

The fix is a tiny piece of arithmetic you can do on paper, and it starts with learning to read the address.

Here's the puzzle.

Scenario. You're the new technician at a small Tulsa company. The boss bought one block of addresses — 192.168.10.0/24, all 256 of them — and four server racks that must stay separated: the web rack (40 servers), the database rack (12 servers), the management rack (6 servers), and a spare rack for future growth. The boss wants each rack on its own subnet so a misbehaving web server can't wander into the database's hallway. You get to carve the block into 4 equal pieces.

Given artifacts. The address block and the four racks:

Address block: 192.168.10.0/24  →  addresses 192.168.10.0 through 192.168.10.255 (256 total)
Rack WEB:   40 servers — needs its own subnet
Rack DB:    12 servers — needs its own subnet
Rack MGMT:   6 servers — needs its own subnet
Rack SPARE:  future growth — needs its own subnet
Four servers already have addresses — after carving, say which rack each belongs to:
  192.168.10.17      192.168.10.66      192.168.10.130      192.168.10.200
Rule of thumb (given): the first usable address in a subnet is traditionally the gateway —
the "front door" every device in that hallway uses to leave it.

Your task: Carve 192.168.10.0/24 into 4 equal subnets (one per rack, in WEB / DB / MGMT / SPARE order), state each subnet in CIDR form with its gateway address, and place each of the four given server addresses into its rack.

Workspace: Analyze-and-answer. Type your four CIDR blocks, four gateways, and four placements. Then open the site's subnet calculator tool and check your arithmetic against it — the tool confirms or corrects, but the reasoning must be yours first.

Commitment ritual: ☐ "I've attempted this challenge and thought it through." Check the box (your answer above is recorded either way) and the worked answer in S7 reveals. Nothing is graded — the struggle is the point.

Four numbers, three dots

An IPv4 address (the classic network address label — four numbers separated by dots, like 192.168.10.17) is the street address from the last lesson, written in the format the whole internet agreed on. Each of the four numbers is called an octet (one of the four numbers in an IPv4 address — "octet" because each one is 8 binary digits, ranging 0–255). Four octets, each 0 to 255, gives about 4.3 billion possible addresses — plenty for 1983, and the reason the world later needed a longer format you'll meet in Module 2.

Why this matters for the challenge: before you can carve 192.168.10.0/24, you must read it: four octets, each 0–255. The carving happens inside those numbers.

The building number and the door number

Here's the key insight: every IPv4 address is really two addresses glued together. The front part names the network — the building. The back part names the device inside it — the door. The network portion (the front part of an address, identifying which network the device belongs to) is what routers read to pick the right building; the host portion (the back part, identifying the specific device inside that network) picks the door once you're in the right hallway. Two devices with the same network portion are neighbors — same building, different doors.

Why this matters for the challenge: carving one network into subnets means redrawing the line between "building" and "door" — stealing digits from the door numbers to make more building numbers.

The slash tells you where the line is

How does anyone know where the network portion ends and the host portion begins? The subnet mask (a second label, written alongside every address, that marks which octets are "building" and which are "door") draws that line — and engineers almost always write it in shorthand called CIDR notation (pronounced "cider" — a slash plus a number, like /24, counting how many of the address's 32 binary digits belong to the network portion). /24 means the first 24 digits (three full octets) are the building, leaving 8 digits for doors: 2⁸ = 256 addresses. /16 leaves 16 digits for doors: 65,536 addresses. Bigger slash number, smaller building, fewer doors.

Why this matters for the challenge: the "/24" in your block is the starting line. Carving means moving that line — and every move doubles the number of buildings while halving the doors in each.

Why carve at all: hallways, not ballrooms

Why not put all 256 devices in one big happy network? Because networks, like apartment buildings, work better with hallways. A subnet (a smaller network carved out of a bigger one — one hallway inside the building) keeps groups separated: the web servers chatter among themselves without their noise reaching the database servers, and a misconfigured web server can't accidentally claim to be the database. Broadcasts — messages shouted to everyone in the hallway — stay in their hallway instead of bothering the whole building. At hyperscale this isn't tidiness, it's survival: thousands of subnets keep millions of servers manageable.

Why this matters for the challenge: the boss's four racks are four hallways. Your carve is what builds the walls between them.

The front door of every hallway

One address in each subnet has a special job: the gateway (the address every device in a subnet uses as its "front door" — the router it sends packets to when the destination is outside its own hallway). By tradition it's the first usable address in the subnet. A device that wants to reach another hallway doesn't need the whole map — it just walks to the front door and hands its packet to the gateway, which knows the way out. Without a gateway configured, a server can talk to its hallway neighbors and nobody else — the network equivalent of a building with no exit.

Why this matters for the challenge: the deliverable asks for each subnet's gateway. It's always the first usable address — the .1 of whatever block you carved.

Watching a carve happen (a different example)

Let's carve once together — on different numbers than your challenge, so the reasoning stays yours. Take 10.20.30.0/24 and split it into two equal subnets for an office and a lab. A /24 holds 256 addresses; half is 128; the slash for 128-address blocks is /25 (one more network digit borrowed from the doors). The two blocks start at multiples of 128: 10.20.30.0/25 (doors .1–.126, gateway 10.20.30.1) and 10.20.30.128/25 (doors .129–.254, gateway 10.20.30.129). Notice .0 and .127/.255 are reserved as the hallway's "name" and "shout to everyone" addresses — never assigned to devices. Same recipe you'll use in the challenge — we'll solve that one in the worked answer.

• An IPv4 address is two addresses glued together — the network portion (which building) and the host portion (which door) — and the slash tells you where the line is.
• CIDR notation counts network bits: each extra bit doubles the number of subnets and halves the addresses in each.
• A subnet is a hallway with walls: it keeps groups separated and keeps shout-to-everyone traffic from bothering the whole building.
• The gateway — traditionally the first usable address — is each hallway's front door; without it, a device can only talk to its own neighbors.
• New subnet boundaries always land on multiples of the block size — if your boundary isn't a multiple, your arithmetic slipped.

Next: Your First Lab — Make Two Servers Talk — you can read addresses and carve subnets on paper; now you'll hand two real servers their addresses and make them actually speak to each other. Try it live in the subnet calculator first if you want a warm-up.