TCP Working: 3-Way Handshake & Reliable Communication
Understanding the Basics of TCP: The 3-Way Handshake and Reliable Data Transfer
🧑 Overview
When you send data over the internet, there’s no guarantee it will arrive.
That sounds scary, but it’s the default reality.
Networks drop packets. Routes change. Machines get busy. Data can arrive late, arrive twice, or arrive out of order. If we just started sending important data without any rules, most applications would break constantly.
Yet your web pages load correctly.
Your API responses are complete.
Your file downloads don’t arrive half-broken.
That reliability comes from TCP.
What Is TCP and Why Is It Needed
TCP (Transmission Control Protocol) exists to make communication reliable on an unreliable network.
It doesn’t make the internet faster.
It doesn’t care what the data means.
Its job is simple but critical:
Make sure data reaches the other side correctly, completely, and in order.
Without TCP, every application would have to invent its own way to handle lost data, duplicates, and broken connections.
TCP solves those problems once — so applications don’t have to.
Problems TCP Is Designed to Solve
Imagine sending a long message where:
parts go missing
parts arrive twice
parts arrive in the wrong order
the receiver isn’t ready
That’s exactly what can happen on a raw network.
TCP is specifically designed to solve:
data loss
out-of-order delivery
duplicate packets
unknown receiver state
It adds structure and trust to a system that has none by default.
What Is the TCP 3-Way Handshake
Before TCP sends any real data, it first establishes a connection.
This process is called the 3-Way Handshake.
Think of it like starting a phone call.
You don’t start speaking immediately.
First, you check if the other person is there and ready.
TCP does the same thing — in three clear steps.
Step-by-Step: SYN, SYN-ACK, ACK
Let’s walk through it slowly using a simple conversation analogy.
Step 1: SYN (Client → Server)
The client sends a message saying:
“Hey, I want to talk. Are you available?”
This message is called SYN (synchronize).
It also includes a starting number, called a sequence number, which TCP will use later to track data.
Step 2: SYN-ACK (Server → Client)
If the server is ready, it replies:
“Yes, I’m available — and I hear you.”
This response is SYN-ACK:
SYN → “I want to synchronize too”
ACK → “I acknowledge your request”
The server also sends its own sequence number.
Step 3: ACK (Client → Server)
Finally, the client replies:
“Great, I got your response. Let’s start.”
This ACK confirms the connection.
At this point both sides agree:
the connection exists
both are ready
both know how to track data
The connection is now established.
How Data Transfer Works in TCP
Once the handshake is complete, actual data starts flowing.
TCP does not send data blindly.
It sends data in chunks, and every chunk has a sequence number.
The receiver uses these numbers to:
reassemble the correct order
detect missing pieces
ignore duplicates
After receiving data, the receiver sends acknowledgements (ACKs):
“I’ve received everything up to this point.”
How TCP Ensures Reliability, Order, and Correctness
This is where TCP quietly does its most important work.
If a chunk of data doesn’t arrive, the sender notices the missing acknowledgement and resends only the missing data.
If data arrives out of order → TCP rearranges it.
If data arrives twice → TCP discards the duplicate.
From the application’s point of view, everything looks clean and simple — even though the network underneath may be chaotic.
How a TCP Connection Is Closed
Ending a TCP connection is also handled carefully.
Either side can say:
“I’m done sending data.”
This is done using a FIN message.
The other side replies with an ACK confirming it received the message.
Then it sends its own FIN when it is finished.
This ensures:
no data is cut off mid-transfer
both sides agree the conversation is over
The connection closes cleanly.
🎯Final Thoughts
TCP isn’t flashy, but it’s one of the most important pieces of the internet.
It doesn’t make apps faster.
It makes them trustworthy.
The 3-way handshake ensures both sides are ready.
Sequence numbers and acknowledgements keep data correct.
Retransmissions fix problems without bothering the application.
That’s why HTTP, APIs, databases, and most web systems rely on TCP.
Once you understand TCP as a careful conversation — not just a protocol — its design starts to feel obvious.
