Every time you open a website, check cricket scores, or log into your bank, a set of invisible rules springs into action behind the scenes. These rules are called communication protocols, and they decide how your device talks to a server somewhere across the world. Without them, the internet would simply be noise. Three protocols sit at the heart of this story: HTTP, which powers almost every webpage you visit; WAP, which brought the web to early mobile phones; and LTP, which keeps data flowing across the most extreme networks imaginable. Understanding them helps you see how a simple click turns into a fully loaded page.
Table of Contents
HTTP: The protocol behind the web
Hypertext Transfer Protocol (HTTP) is the foundation of data exchange on the World Wide Web. It is a set of rules that governs how a client, usually your web browser, talks to a server that stores web content. Whenever you type a web address and press enter, HTTP is what carries your request to the server and brings the answer back to your screen.
HTTP works on what is called a request-response model. Your browser sends a request, and the server sends back a response containing the requested webpage, image, or file. The two most common types of requests are GET, used to retrieve data, and POST, used to send data to the server. HTTP also sits at the very top of the network communication model, working as an application layer protocol while relying on lower layers to actually move the data.
Why HTTP is described as stateless
One key feature of HTTP is that it is stateless. Each request is treated as completely independent, and the server does not automatically remember anything about your previous requests. This keeps the protocol simple and fast, but it also means that features like staying logged into a website rely on extra tools such as cookies and sessions to remember who you are between requests.
When a server responds, it includes a status code that tells your browser what happened. You have probably seen the famous 404 Not Found error. A successful request, on the other hand, usually returns a 200 status code, which simply means everything went fine and the content is on its way.
From HTTP to HTTPS: adding security
Plain HTTP has a serious weakness. It sends data as plain text, which means anyone monitoring the network, such as on public Wi-Fi, can potentially read or alter it. This makes it vulnerable to interception and tampering, a problem when you are entering passwords or card details.
HTTPS (Hypertext Transfer Protocol Secure) solves this. It is essentially HTTP layered over an encryption protocol called Transport Layer Security (TLS), previously known as SSL. Before any real data is exchanged, the browser and server establish a secure, encrypted connection. HTTPS provides three things plain HTTP cannot: confidentiality so eavesdroppers cannot read your data, integrity so the content cannot be silently changed, and authentication through a certificate that proves the website is genuine.
Today, HTTPS is the default for the modern web. Browsers now mark plain HTTP pages as “Not Secure”, and search engines treat HTTPS as a ranking signal. If you bank online or shop on an e-commerce site, the small padlock in your address bar is HTTPS quietly doing its job.
Wireless Application Protocol (WAP)
Long before smartphones, accessing the internet on a mobile phone was a very different experience. Screens were tiny, processing power was limited, and network speeds were painfully slow, often around 9.6 kilobits per second on early GSM connections. Regular web pages, designed for desktop computers, were simply too heavy to load. This is the problem the Wireless Application Protocol (WAP) was built to solve.
WAP was a specification for a set of communication protocols that standardised how wireless devices could access internet services like the web, email, and messaging. It was created in 1997 by Ericsson, Motorola, Nokia, and Unwired Planet at a gathering known as the WAP Forum. Before WAP, every manufacturer used its own technology, which created a fragmented mess. WAP aimed to bring everyone onto a common standard.
How WAP actually worked
WAP did not send normal web pages to phones. Instead, it used a lighter markup language called WML (Wireless Markup Language), a stripped-down cousin of HTML designed for small screens and slow networks. The clever part of the system was a piece of middleware called the WAP gateway.
When you requested a page on a WAP phone, the request travelled over the cellular network to this gateway. The gateway acted as a translator, converting your request into a standard web request, fetching the content, and then compressing and reformatting it into a mobile-friendly form before sending it back to your phone. A small WAP browser on the device then displayed it.
The WAP protocol stack
WAP had its own layered protocol stack that deliberately mirrored the structure of the internet’s TCP/IP model, but optimised for wireless conditions. It included layers such as the Wireless Session Protocol (WSP) for managing sessions, Wireless Transport Layer Security (WTLS) for security, and the Wireless Datagram Protocol (WDP) for data delivery. Each layer had one job: to make the internet usable when bandwidth and memory were almost nonexistent.
WAP is now considered obsolete. As phones grew more powerful and gained full HTML browsers and faster networks, the need for a separate translated experience faded, and its use declined sharply through the 2010s. Yet WAP mattered enormously. It proved that mobile internet was possible and laid the groundwork for the smartphone-driven web we use today.
Licklider Transmission Protocol (LTP)
The third protocol takes us to the most extreme edges of networking. The LTP, or Licklider Transmission Protocol, is designed for efficient and reliable data transfer in highly constrained, “challenged” networks where ordinary protocols like TCP simply break down. It is a core part of an approach called Delay/Disruption Tolerant Networking (DTN).
To understand why a special protocol is needed, consider the problem it was built for: deep-space communication. When data has to travel from a spacecraft near Mars back to Earth, signals face extremely long propagation delays of several minutes, frequent and lengthy link disruptions, and very lossy channels. The familiar internet protocols assume a connection is more or less continuous and fast, so they fail in these conditions.
How LTP handles difficult links
LTP was proposed for reliable data delivery in environments where existing transport protocols do not perform effectively. It is built for point-to-point connections that have huge delays and may be interrupted often. The protocol was formally described by the Internet Engineering Task Force in RFC 5325 and related documents, giving it a recognised standard rather than being a one-off experiment.
One of its smart design choices is offering both reliable and unreliable delivery within the same transmission. Data can be split into a “red” part that must be confirmed and retransmitted if lost, and a “green” part that is sent without that guarantee. This lets engineers prioritise critical information while saving precious time on data that can tolerate some loss, which matters when a single retransmission across space can cost minutes or even hours.
While LTP began as a solution for space agencies, the lessons it teaches about designing for poor connectivity, packet loss, and session interruptions are increasingly relevant on Earth too, including for remote sensors and certain Internet of Things deployments operating in tough conditions.
Future trends in web communication
Protocols never stand still. The most significant recent shift on the everyday web is HTTP/3, the third major version of HTTP, finalised as RFC 9114 in 2022. The surprising change is what runs underneath it. Instead of the long-serving TCP, HTTP/3 is built on a new transport protocol called QUIC.
QUIC runs over UDP and was engineered for a fast, mobile, and latency-sensitive internet. It tackles a long-standing problem called head-of-line blocking, where one lost packet in TCP forces every following packet to wait. QUIC lets each data stream move independently, so a single loss does not stall everything else. It also bakes encryption directly into the transport layer, removing the need for a separate, slow TLS handshake and speeding up the initial connection.
For users on mobile networks, which describes a huge share of internet users in India, this is a real improvement. QUIC uses a connection ID so that a session can survive even when your device switches between Wi-Fi and mobile data without dropping the connection. The performance gain is largest exactly where networks are weakest. HTTP/3 is no longer experimental, with major browsers, content delivery networks, and a steadily growing share of global web traffic already using it. The clear direction of travel is towards protocols that are faster, encrypted by default, and resilient on the imperfect, mobile-first networks most of us actually use.
What do you think? Now that you know how much work happens behind a single page load, how often do you check whether a site is using HTTPS before entering sensitive information? And given how WAP shaped early mobile internet, which of today’s protocols do you think will look as outdated in twenty years?
References
- https://aws.amazon.com/compare/the-difference-between-https-and-http/
- https://www.cloudflare.com/learning/ssl/why-is-http-not-secure/
- https://http.dev/https
- https://www.techtarget.com/searchmobilecomputing/definition/WAP
- https://www.rfpage.com/wireless-application-protocol/
- https://ieeexplore.ieee.org/document/5683496/
- https://www.rfc-editor.org/info/rfc5325
- https://www.rfc-editor.org/info/rfc9114
- https://www.infoworld.com/article/3497016/what-is-http-3-the-next-generation-web-protocol.html

Leave a Reply