In 1990–1994, the Web’s “API surface” was mostly URLs, HTTP methods, and early server scripts—not JavaScript calling APIs. This chapter explains how that era set up the later need for CORS and modern cross-origin rules.
In the Web’s first years (1990–1994), HTTP was tiny, servers were simple, and “APIs” mostly meant speaking basic request/response over the network. Those constraints later produced AJAX—and eventually the Fetch API, which modernized the same fundamental idea.
From 1990 to 1994, the Web’s earliest HTTP interfaces were built for document retrieval, not event delivery. This chapter explains how those design choices delayed “push” and web notifications—and why that mattered for later web APIs.
Service Workers arrived decades after the Web’s birth, but the offline-first mindset has technical roots in the earliest HTTP interfaces, caching behavior, and the Web’s original stateless architecture (1990–1994).
WebRTC arrived decades later, but its DNA traces back to the Web’s first years: early HTTP rules, headers, content types, and gateway patterns that taught browsers how to negotiate capabilities.
In 1990–1994, the Web’s earliest HTTP interactions were simple, document-centric, and slow by today’s standards—but they established the core constraints that later pushed developers toward service-style APIs and, eventually, high-performance systems like gRPC.
In the Web’s first years, “APIs” were often just URLs and forms hitting CGI scripts. Those primitive HTTP interfaces introduced a surprisingly modern idea: clients can influence what data they get back—an early ancestor of today’s client-driven data fetching and GraphQL-style thinking.
In the Web’s earliest years, developers used simple HTTP interfaces, CGI scripts, and server modules to stitch together internal systems. This chapter traces how those early patterns anticipated microservices and modern internal API ecosystems.
From CERN’s early Web servers to proxies, protocol gateways, and CGI entry points, the years 1990–1994 introduced the core idea behind API gateways: one place to route, observe, and control traffic headed to many backends.
Swagger and OpenAPI feel modern, but their core ideas—contracts, endpoints, headers, and examples—trace back to the Web’s earliest HTTP interfaces. This chapter looks at 1990–1994 documentation practices that quietly set the pattern for today’s API tooling.