Client-Server vs. Peer-to-Peer

The Restaurant vs. The Potluck

The Application Layer is where protocols like HTTP, DNS, SMTP, and BitTorrent live. It doesn't move bits across wires — that's the job of lower layers — it defines how programs structure their conversation: who speaks first, what a request looks like, and what counts as a valid reply. Every architecture choice in this tutorial happens at this layer.

Application Layer Protocols You Use Every Day

Client-Server Architecture

In client-server architecture, roles are fixed. The server is a program that sits and waits, listening on a network port, ready to answer requests. The client is the program that initiates contact — asking a question, the server answers, and the exchange usually ends there until the next request.

Peer-to-Peer (P2P) Architecture

In peer-to-peer architecture, there is no fixed server role. Every participant — called a peer — can act as both client and server at once: requesting data from other peers while also serving data it holds to whoever asks. Some P2P systems still use a small central server just to help peers find each other (like a torrent tracker), but the actual data transfer happens directly, peer to peer.

Head-to-Head Comparison

Real Case — When Napster Proved P2P's Legal Blind Spot

Real Case — GitHub's Record-Breaking DDoS Attack

Real Case — The AWS Outage That Took Half the Internet Down

Hybrid Architectures — The Best of Both Worlds

Build Your Own Server, Part 1 — A Minimal HTTP Server

Let's make the theory concrete. You'll build a real client-server system: a server that listens on a port, and a client (your browser, or curl) that talks to it. We'll use Node.js, since it can spin up a working server in a handful of lines.

server.js — an HTTP server that answers every request

const http = require('http');

// The server: waits for connections and decides how to respond
const server = http.createServer((req, res) => {
  console.log(`Request received: ${req.method} ${req.url}`);

  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello from my own server!\n');
});

// Start listening on port 3000
server.listen(3000, () => {
  console.log('Server running at http://localhost:3000/');
});

$ node server.js

Now open a second terminal — this is your client — and make a request:

$ curl http://localhost:3000/

Build Your Own Server, Part 2 — A Raw TCP Socket Server

HTTP is itself just an application-layer protocol built on top of TCP. To really see the client-server pattern stripped down to its bones, let's skip HTTP entirely and talk directly over a TCP socket — the same transport that HTTP, SMTP, and almost everything else in this tutorial ultimately runs on.

tcp-server.js — a raw echo server

const net = require('net');

const server = net.createServer((socket) => {
  console.log('Client connected:', socket.remoteAddress);

  socket.on('data', (data) => {
    console.log('Received:', data.toString().trim());
    socket.write(`Echo: ${data}`); // send it right back
  });

  socket.on('end', () => console.log('Client disconnected'));
});

server.listen(9000, () => console.log('TCP server listening on port 9000'));

Run it, then connect from a second terminal using netcat (your raw TCP client):

$ node tcp-server.js
$ nc localhost 9000
hello server

Testing Your Server Like a Real Client

Taking Your Server Public

A server running on localhost only answers your own machine. To let real clients on the internet reach it, you need a public address and a few safety nets in front of it.

Securing the Server You Just Built

Which Architecture Should You Choose?