Specifying IP Addresses

Every system connected to an IP network needs an address so that data can be delivered to the correct destination. On the public Internet and inside private cloud networks, that address is usually an IP address. When a user types a domain name such as seotrance.com, the browser does not send requests based on the text name alone. Instead, the name is resolved through DNS into an IP address, and that address is then used by the network stack to route traffic toward the correct host.

This distinction is important. A domain name is a human-friendly identifier, while an IP address is a network-layer address used by Internet Protocol. Routers examine IP header information to forward packets from one network to another. The browser, server, operating system, and intermediate network devices all rely on IP addressing to make communication possible.

In older classroom explanations, TCP and IP were often described together so tightly that they sounded like one mechanism. In reality, they perform different jobs. IP is responsible for logical addressing and routing across networks. TCP operates above IP and provides reliable transport, ordered delivery, retransmission, and flow control when an application needs those features. In other words, IP helps packets find the destination, while TCP helps the application receive complete and properly ordered data once those packets are in transit.

This layered view matters in modern web architecture. A website request today may pass through a local router, ISP backbone, CDN edge, cloud load balancer, reverse proxy, and application server before a response comes back to the browser. At each stage, IP addressing remains fundamental because every network device needs a standard way to identify destinations and forward traffic.

The most familiar format is IPv4. An IPv4 address is a 32-bit number, traditionally written in dotted-decimal notation as four decimal values separated by periods, such as 138.104.223.100. Each of those four values is commonly called an octet, because each represents 8 bits. Since an octet can hold 8 bits, each decimal section ranges from 0 to 255.

This notation is much easier for humans to read than a raw binary value. For example, the address 145.10.34.3 can also be represented as 32 binary bits, but dotted-decimal notation is more practical for documentation, configuration, training, and troubleshooting. The address itself identifies an interface on an IP network, not merely a website. A web server, router, virtual machine, container host, or laptop can all be assigned IP addresses as part of network communication.

Older networking lessons often explained IPv4 using a fixed idea of “network portion” and “host portion” based on octet boundaries. That reflected the older classful addressing model. Modern networks are better explained with CIDR (Classless Inter-Domain Routing), which uses a prefix length such as /24 or /16 to indicate how much of the address represents the network prefix. CIDR replaced rigid class-based thinking because it uses address space more efficiently and scales better for routing and subnetting.

The lesson objective asks not only how IP addresses are specified, but also what role TCP plays. TCP does not create the addressing system. That is IP’s responsibility. Instead, TCP uses IP as the delivery foundation. Once DNS resolves a domain name to an IP address and the destination is reachable across the network, TCP can open a connection between endpoints using IP addresses and port numbers.
A useful way to think about this is as follows:

• IP address identifies where the packet should go.
• Port number identifies which service or application on that host should receive the traffic.
• TCP provides reliable ordered delivery for the conversation that uses those addresses and ports.

For web traffic, that often means a browser connects to a server IP on a port such as 443 for HTTPS. IP handles addressing and routing. TCP handles the reliable exchange of application data. Then higher-level protocols such as HTTP or HTTPS define the request and response semantics that the browser and server understand.

This layered stack is why the topic is sometimes called the TCP/IP stack. It is a collection of cooperating protocols rather than a single mechanism. Understanding that separation helps students avoid a very common misconception: the address belongs to IP, not to TCP, even though TCP commonly uses IP underneath it.

A public IP address is reachable on the public Internet and must be globally unique within Internet routing policy. These addresses are what allow public-facing services such as websites, APIs, email gateways, and CDN endpoints to receive traffic from users across the Internet.

A private IP address is used within internal networks and is not globally routable on the public Internet. In IPv4, the best-known private address ranges are:

• 10.0.0.0/8
• 172.16.0.0/12
• 192.168.0.0/16

These private IPv4 ranges were standardized to support internal networks without requiring globally unique public space for every internal device. Private addressing is common in homes, offices, data centers, and cloud environments. A laptop on a home network, a Kubernetes node inside a private subnet, and a database server inside a VPC may all use private addresses that are valid only inside their respective internal networks.

This is a major modernization point for the lesson. Legacy networking examples often assumed that a “website address” meant one public IP bound directly to one host. In modern infrastructure, a web application may sit behind NAT, a reverse proxy, a load balancer, or a CDN. The origin server may use only private IP addresses while the public-facing endpoint uses a different public address or edge service. That separation is a normal part of current web deployment practice.

A modern lesson on IP addressing should also include IPv6. IPv6 was developed to address the limitations of IPv4 address space and to provide a much larger addressing architecture. Where IPv4 uses 32 bits, IPv6 uses 128 bits. IPv6 addresses are written in hexadecimal groups separated by colons, such as 2001:0db8:85a3:0000:0000:8a2e:0370:7334. Because the notation can become long, IPv6 allows certain zero-compression rules to shorten the text representation.

IPv6 matters because the public Internet, mobile networks, cloud platforms, and large-scale services increasingly operate in dual-stack or IPv6-aware environments. Even when a student first learns IP addressing through IPv4 examples, contemporary best practice is to understand that IP addressing today includes both IPv4 and IPv6 design considerations.

For digital presence and web deployment, IPv6 support can affect accessibility, scalability, CDN compatibility, and future readiness. A modern public web platform should not assume that IPv4 alone defines Internet identity.

To see how these concepts fit together, consider a user visiting a website. The browser first resolves the domain name using DNS. DNS returns one or more IP addresses associated with the hostname. The client then uses IP to reach the appropriate destination. If the site uses a TCP-based protocol such as HTTPS over HTTP/1.1 or HTTP/2, TCP establishes a connection to the destination IP and port. After that, the browser sends the HTTP request and receives the response.

This sequence shows why IP addresses are essential even when users think in terms of domain names. The domain name is convenient for humans, but the network stack still depends on IP-level addressing to actually deliver the traffic.

It is also worth noting that some modern web traffic now uses HTTP/3, which relies on QUIC over UDP rather than TCP. Even in that case, IP addressing remains fundamental. The transport behavior changes, but the destination addressing and routing still depend on Internet Protocol.

The TCP/IP stack strongly influences how cloud infrastructure is designed. In cloud platforms such as AWS and Azure, workloads are usually deployed inside virtual private networks that allocate private IP addresses from defined subnet ranges. Instances, virtual machines, containers, load balancers, managed databases, and other services communicate over those internal IP networks. Public Internet access is added selectively where needed rather than assumed by default.

This model is central to secure web deployment. A public-facing load balancer may receive requests from the Internet on a public address, while the application servers behind it use private IPv4 addresses. Those private addresses are still fully functional for east-west traffic within the environment, and the platform controls routing, translation, and exposure boundaries.

For example, AWS VPC documentation explains that instances are assigned private IPv4 addresses from the subnet range and only receive public IPv4 addresses when the subnet configuration or launch settings allow it. Azure likewise assigns private IP addresses from the virtual network subnet range. This means modern web deployment is not just about “getting one IP address for a website.” It is about designing subnets, routing, DNS behavior, exposure boundaries, and transport paths across layered infrastructure.

This is where the older T1/T3 deployment mindset gives way to a modern one. Instead of picturing a single leased line and a single exposed host, today’s architectures often involve fiber broadband, cloud connectivity, SD-WAN, dual-stack networks, managed edge services, and segmented private address spaces. The addressing model becomes part of platform architecture, security posture, and application resilience.

When teaching or documenting IP addressing in a modern context, several best practices are helpful:

• Explain both IPv4 and IPv6, not IPv4 alone.
• Use CIDR notation instead of relying only on older classful explanations.
• Differentiate clearly between domain names, IP addresses, and transport protocols.
• Explain public versus private addressing in the context of cloud and internal networks.
• Show how TCP relies on IP addressing without confusing TCP with IP itself.
• Frame IP addressing as part of a larger web delivery path that may include DNS, TLS, CDNs, proxies, and cloud load balancers.

These adjustments make the lesson more useful for students working with current platforms, tooling, and deployment patterns.

IP addresses are the numerical identifiers that allow devices and services to participate in network communication. In IPv4, an address uses 32 bits and is typically written as four decimal octets. In modern networking, addresses are usually interpreted with CIDR prefix lengths rather than old class-based assumptions. Public IP addresses support Internet-facing communication, while private IP addresses support internal networking in homes, enterprises, and cloud platforms.

TCP plays a critical but distinct role. IP specifies where traffic should go, while TCP helps ensure that data arrives reliably and in order once the destination has been reached. Together with DNS and higher-level web protocols, this layered design makes modern Internet communication possible.

In the next lesson, the discussion can naturally move toward remote and web system protocols, because once students understand how hosts are named and addressed, it becomes much easier to understand how applications communicate across those hosts in practice.

[1]Internet address: a numerical or alphanumeric network identifier used to locate a device, interface, or service within a networked communication system.