I've been having the nostalgia lately. Hard.
It's not exactly a mystery. The last few months have involved more professional self-examination than any reasonable person should inflict on themselves: a resume I apparently still need to have, a portfolio that required excavating work I'd genuinely forgotten I'd done, and a few hundred articles I proofread with the expression of someone reviewing old photographs and thinking "well, I certainly had opinions." Twenty-four years of opinions, as of this morning. Twenty-four years as a card-carrying adult professional whose medium is the web.
A medium that has, for twenty-four years and counting, absolutely refused to pick a fucking lane.
This is not a complaint. Not entirely. The people who work in this space are employed precisely because the medium never stops moving, which is a blessing and a specific kind of exhaustion that is difficult to explain to anyone outside of it. The web has been in continuous reinvention since roughly 1990, which means the people who build it have been continuously reinventing themselves to match, which is either thrilling or terrible depending on the week. Sometimes both before lunch.
What follows is my attempt to run through as many of those reinventions as I can remember, in rough chronological order, with commentary from someone who was around for most of them.
1990–1995: Hello World
Everything crude about the early web was a function of survival, not vision.
I want to say clearly that I was not there. The nostalgia doesn't extend to a time I spent in grade school while Tim Berners-Lee was inventing the web at CERN on a NeXT machine wearing a handwritten label that read "This machine is a server. DO NOT POWER IT DOWN!!" That label is real. The entire World Wide Web lived, briefly, on a box that was one accidental keyboard bump away from being switched off by a physicist looking for an outlet.
You can see the fingerprints of that fragility all over the era's output. When your primary engineering concern is whether the server stays on, you do not sweat the presentation layer. So: Times New Roman on white, <table> elements holding up layouts they were never designed to hold, and spacer GIFs, single transparent pixels pressed into service as padding because CSS did not yet exist to say the word "margin." Images weren't possible at all until 1993, when Mosaic implemented the img tag without asking anyone's permission, establishing the proud browser tradition of doing whatever the fuck it wants with HTML and leaving the rest of us to handle the fallout.
Search existed but hadn't decided it was a business yet; Archie, Lycos, AltaVista were experiments in whether "people looking for things" could be turned into money. Nobody had yet worked out that helping people find things was about to become one of the largest businesses in the history of the species. And if you wanted anything on a page to move, you wrote CGI scripts in Perl or C, which selected for a specific temperament: the kind that enjoys managing memory by hand and finds comfort in the compilation step. The soil was fertile. It was also extremely demanding about who got to plant in it.
1995–2000: The First Bubble
The defining event of this era wasn't the money. It was that the time required to iterate collapsed, and that collapse minted a generation of people who built things without ever calling themselves programmers.
Here is the whole revolution in one sentence: you could edit a file, FTP it to the server, reload the page, and see the change. That sounds like nothing now. At the time it dropped the cost of an experiment from "wait for the build" to "upload and reload," and that single difference is why PHP, ASP, and JSP turned server-side scripting from a specialty into a Tuesday. Databases showed up in earnest, MySQL and PostgreSQL and some early Microsoft Access deployments that aged exactly as well as you'd guess, and suddenly you could store a thing and get it back, which is the unglamorous door that everything else walked through: guestbooks, forums, accounts, carts, the entire shape of what we now call a web application. Amazon and eBay both went live in 1995. Neither knew what it was yet. Neither did anyone.
JavaScript arrived in 1995, built by Brendan Eich at Netscape in roughly ten days, a timeline that will surprise nobody who has spent an afternoon with the language. Rollover effects, dropdown menus, form validation that didn't require a round trip; modest now, genuinely impressive enough to put on a demo reel then. CSS followed in 1996 with the admirable goal of separating content from presentation, and the browsers received that goal with the enthusiasm of a contractor told to follow blueprints he wasn't consulted on. The theory was correct. The practice, for the next decade, was an ongoing negotiation between what the spec said and what the browser felt like doing.
The through-line of the era is a tradeoff that has recurred at every abstraction layer since. Flash let you build things HTML couldn't, which was nearly anything visually alive, at the eventual cost of a security surface roughly the size of a continent. FrontPage and Dreamweaver let people who couldn't hand-write HTML ship anyway, at the cost of HTML the hand-writers spent years cleaning up. Make it accessible, lose some control over what comes out. Write that down; you'll see it again.
Billions were raised, billions were lost, and the Netscape-versus-IE browser wars drove features faster than the standards bodies could ratify them, which meant you wrote everything twice and prayed the two results were close enough to ship. "Works in Internet Explorer" and "works" were different sentences.
2000–2005: The Professionalization
The bust didn't kill the web. It professionalized it, and the arguments that started here never got resolved; they just got better marketing.
Companies that had raised on the theory that revenue was a detail to sort out after scale were abruptly asked to sort it out now, and what survived was leaner and more interested in whether the thing worked than in whether the deck did. This is when web development stopped being a frontier and started being a job. The W3C pushed HTML 4 and CSS 2 with real urgency about semantics and accessibility, DOM standardization brought enough order that you could write cross-browser JavaScript without a séance, and the LAMP stack became the default such that if you weren't on Linux, Apache, MySQL, and PHP, you had a reason, and it wasn't necessarily a good one.
The best fight of the era arrived with the CMS, and it has never fully ended because it was never really about software. One camp built tools to let anyone publish: abstract everything behind an interface, get words on a page, don't make the user think about structure at all. The other built tools to let developers model content precisely and expose it through interfaces they controlled, on the theory that structure isn't a detail you paper over; it's the whole job. WordPress (2003) planted its flag in the first camp and won the numbers. ExpressionEngine (2002) and Drupal held the second, and got called niche for a decade by an industry that would spend the 2020s expensively reinventing everything those tools already did. These weren't competing products so much as opposite answers to a question nobody wanted to say out loud: who is this CMS actually for, the person publishing or the person building? Pick one and you alienate the other. Refuse to pick and you ship a compromise that serves neither, then act surprised when both sides leave.
Before packaged CMSs became the default, almost every agency quietly had its own. Every company I worked for had one. Different names, different opinions about architecture, but underneath they all did roughly the same thing: edit content, upload images, manage navigation, publish pages. We'd independently reinvented the same CMS over and over again without realizing that's exactly what we were doing. They always had an ambitious internal name, too. Community Activation Tool (CAT). Controller. The System. Whatever branding made it feel like proprietary magic instead of a glorified admin panel sitting on top of a handful of database tables. Every new client inherited the last client's codebase with enough search-and-replace to convince ourselves we were building bespoke software, when in reality we were just maintaining our own private CMS.
Then WordPress, ExpressionEngine, osCommerce, and dozens of others arrived, and it felt revelatory. Not because they introduced ideas we'd never considered, but because someone finally admitted these weren't unique problems worth solving from scratch every six months. Authentication wasn't our competitive advantage. Neither was an image uploader. Neither was a WYSIWYG editor. For the first time, the foundation showed up before the project did, and suddenly we could spend our time building the parts clients actually thought they were paying for.
They had problems, of course. Modern plugin ecosystems barely existed, so customization usually meant editing core files directly. Every upgrade became an archaeological dig through handwritten notes and diff tools, trying to remember why someone had changed line 847 eighteen months earlier. Documentation stopped being a luxury and became survival. It wasn't elegant, but software had finally started compounding instead of resetting back to zero with every new project.
Watch what happened to the question over the next twenty years. A publishing tool became an application framework, which became a content repository, which became an API, and then somebody stapled "headless" to the box and charged venture-capital prices for functionality the structure people had been shipping quietly since 2002. The taxonomy changed. The argument did not. Who owns the content, and how tightly presentation should cling to storage, is the same fight it was when the answer was a MySQL table and a template tag. We just have nicer slide decks for it now.
SEO crystallized in the same window. PageRank had been public since 1998, but this is when "how you structure your HTML and who links to you" acquired direct commercial consequences, which is to say a budget, which is to say developers were suddenly required to hold opinions about it. Meanwhile XMLHttpRequest sat quietly available from around 2000, and developers who mostly didn't know each other were independently discovering that you could update part of a page without reloading all of it. Jesse James Garrett would give it the name AJAX in 2005. The technology was already arriving before the vocabulary was. That would become a pattern.
2005–2010: Web 2.0
Interactivity stopped being decoration and became the point, and the web learned to behave like an application instead of a document.
Tim O'Reilly named Web 2.0 in 2004 and the name stuck because it described something true. Gmail launched the same year and proved to an audience that could see it plainly that a web app could feel like a desktop app; Google Maps followed, and the combination of "your inbox loads without refreshing" and "you can drag a map" was a proof of concept with large commercial stakes stapled to it. If Google was doing this, there was a "this."
Those of us who were there dove in head first and almost immediately cracked our skulls. Words cannot describe how difficult a task it was, at the time, to debug hand written XMLHttpRequest requests that worked on Safari, Internet Explorer, Firefox, and eventually Chrome, and my personally hated browser, Opera. By. Hand. Firefox became my browser of choice for one reason: Firebug. Firebug wasn't just nice. It fundamentally changed debugging. Before Firebug we were basically doing alert(foo); for six hours. But that's all we had. And it only worked on Firefox. We all got really good at writing files to debug that functionality. You kids these days don't know how good you have it...
jQuery arrived in 2006 and made JavaScript tolerable, and I mean that at full strength. It abstracted the browser inconsistencies that had made client-side work feel hostile, its selector syntax was just CSS, which developers already knew, and it won the territory Prototype and MooTools were also contesting because it was small and honest about what it did. A generation of PHP developers who had treated JavaScript as enemy terrain learned jQuery instead and discovered client-side programming could be, if not fun, at least not actively punishing.
Two structural shifts outlived the tooling. Publishing exploded, WordPress and the whole ecosystem of comments and trackbacks and RSS readers around it, and the number of people putting words on the web grew by an order of magnitude, permanently changing what developers were paid to build. And social platforms shipped APIs, so building an application increasingly meant building something wired into other things; third-party integration went from an advanced topic to the baseline, and if your app talked to nothing, it was already behind.
Flash reached peak influence here and began dying of it. The iPhone shipped in 2007 without Flash, and Steve Jobs' eventual open letter ("Flash was created during the PC era") wasn't immediately decisive but was eventually fatal, because the web was obviously going to run on mobile, and Flash was obviously not going to be how.
2010–2015: The Framework Era
For fifteen years the frontend had been the place backend developers were sent to be punished. This is the era it filed for recognition as real engineering, and, in the way of these things, got exactly what it asked for.
The wish arrived in pieces. Ethan Marcotte published Responsive Web Design in 2010 and the ground shifted under everyone at once; the premise was modest, one codebase that adapts to the screen it lands on, and the consequence was that "does it work on mobile" stopped being a question you could answer later. HTML5 and CSS3 landed around the same time with the browser vendors, for once, mostly cooperating: native video and audio retired the Flash embed, canvas made graphics programmable, and animation moved from JavaScript hack to CSS property. The platform was starting to look like a platform.
Then came the architecture, and with it the bill. Angular shipped from Google in 2010 and the single-page application acquired serious institutional backing; Backbone and Ember staked out adjacent ground with their own opinions about how much structure a person should be forced to accept. The shared premise was that the frontend deserved the rigor the backend had enjoyed for years, separation of concerns, explicit data flow, testable units. This was correct, and it was also the moment the frontend inherited every argument the backend had been having since 2003, now conducted in a language its creator had designed in ten days.
Node shipped in 2009 and made the inheritance total. The same language on both ends was, on paper, an efficiency; in practice it meant JavaScript's design decisions, tolerable in the browser because the alternative had been CGI, were now load-bearing on production servers, holding up callback pyramids and an approach to error handling that was, generously, innovative, and less generously, a crime.
Bootstrap arrived from Twitter in 2011 and did the least glamorous, most honest thing of the era: it made a competent interface something a non-designer could ship. Every Bootstrap site looked like a Bootstrap site, which was the joke, and the joke was fair. It was also beside the point. Those sites shipped, worked on mobile, and were navigable without a UX audit, which was not reliably true of the artisanal interfaces they replaced.
By the time REST hardened into the default and JSON quietly buried XML (mostly because it mapped straight onto a JavaScript object, and partly because production XML had accumulated enough angle brackets to constitute a motive), the frontend had gotten its wish: it was finally treated as a first-class engineering discipline. It had frameworks, a build step, architectural doctrine, and its very own category of person who could argue about state management for an hour. Be careful what you file for.
2015–2020: JavaScript Took Over Everything
There's a tidy version of this era where React's rise is the natural endpoint of everything before it. That version isn't wrong, it's just missing the texture, which was less "inevitable progress" and more "a staggering quantity of tooling arriving at once with no agreement on which of it you actually needed."
React shipped from Facebook in 2013 and by 2015 owned the frontend. The virtual DOM and the component model changed how the whole discipline thought, not just React developers but the frameworks that formed in response, Vue and Svelte taking the same ideas seriously enough to build different answers. The component model won outright. The specific implementation is still being argued, and will be after we're dead.
ES6 dragged JavaScript into a shape developers from other languages could recognize, classes and arrow functions and destructuring and modules, and Babel let you use those features before browsers supported them, which is the innocuous-sounding decision that made the build step a permanent resident of frontend work. Where once you wrote a file and put it on a page, you now wrote source that compiled to output through a pipeline of loaders and plugins that could eat more hours than the code it transformed. TypeScript then arrived to make the resulting large codebases legible to tools, and it turned out "legible to tools" was most of what teams had been missing; the type system's overhead bought back the suffering of maintaining a big untyped codebase, and the trade was worth it often enough to become a default.
The quieter, more consequential story is infrastructure finally solving a problem that had been generating "works on my machine" as its primary artifact for decades. Trace the arc: early on you uploaded files over FTP and hoped nobody touched production while you did, and if something broke you re-uploaded the old files and pretended the last ten minutes hadn't happened. Then source control, then centralized builds, then Git, then CI/CD pipelines, and in this era Docker, which let you describe a runtime in a file, check it in, and have real confidence that the laptop and the server bore some relationship to each other.
Nobody writes the conference talk titled "Remember That Time Nothing Exploded During Deployment," and that silence is exactly the achievement. Serverless landed on top of it, AWS Lambda and its kin billing by the millisecond for functions that exist only when invoked, and whether "serverless" meant you'd stopped thinking about servers or just started thinking about them differently was a debate that outlived the era.
2020–2025: AI Arrived and Everyone Was a Senior Developer for About Five Minutes
The Jamstack idea that had been building since the mid-2010s matured here into an actual approach: static-first, API-backed, deployed to CDN edges, fast by default instead of fast by heroics, with Next, Astro, and Eleventy as the vehicles and Contentful, Sanity, and Strapi turning "headless CMS" from a concept into a product category. TypeScript, meanwhile, finished the job; start a new JavaScript project of any size after 2021 without it and you'd better be able to defend the choice in code review.
And then, from late 2022 onward, AI-assisted development became real in a way no previous hype cycle had prepared anyone for. Copilot, ChatGPT, Claude. Every executive who'd spent fifteen minutes with an LLM was suddenly ready to explain software to people who'd shipped it for twenty years, and for about six months LinkedIn became a support group for developers trying to work out whether they were about to be replaced by predictive text.
The answer turned out to be "not exactly," and the reason is the whole story of the era. The tools weren't magic and weren't useless; they were amplifiers. A competent developer got faster. An inexperienced one got more dangerous. And everyone learned, usually the hard way, that "looks correct" and "is correct" are entirely different claims when the thing writing the code has no idea what your application is supposed to do and cannot be embarrassed about being wrong. The models produced genuinely... interesting... output, and they confidently invented functions and whole architectural patterns that had never existed outside their own statistical imagination, which, to be fair, is not that far from some consultants I've worked with.
Which, as a contract programmer, is pretty awesome. Fixing cocky product manager's code has become a bit of a cottage industry for me.
But the thing that actually changed in these years wasn't the technology. It was the conversation around the technology. For twenty years, how software got made had been a discussion held mostly among the people who made it. Then a text box learned to produce plausible code, and everyone who'd spent fifteen minutes with it suddenly had standing. The executive who'd never opened a terminal had opinions about your velocity. The recruiter explained that engineers were about to be optional. The founder who'd read one thread wanted to know why the rewrite couldn't be a weekend. None of them were entirely wrong and none of them were within a mile of right, and the exhausting part was never the tooling. It was defending twenty years of craft to a room that had discovered the subject on Tuesday and considered itself caught up.
Under all of it the ground kept moving the way it always does, edge compute and WebAssembly quietly maturing into real tools while the industry argued about whether it still had jobs; but for the first time in twenty-four years, the technology was the least interesting thing in the room.
What Comes Next (Or: We Have No Idea, Which Is The Point)
AI-native interfaces are coming, and "coming" is too patient a word; the text box that takes natural language and returns structured output is already inside more products than anyone's tracking. What happens to interface design when the primary interface is a conversation is a question the industry has been asking for two years without answering, which means the answer will arrive from a direction nobody's watching.
Web3 did not deliver what it promised, and the decade of blockchain infrastructure built in anticipation of an adoption that never came is being quietly repurposed; decentralized technology without the token economy is a different and possibly more durable proposition, and the infrastructure is sitting right there. Framework churn is giving way to consolidation, React Server Components and SolidStart and Qwik reading less as new frameworks than as evolved answers to problems the last generation identified but didn't finish. And privacy-first analytics like Plausible and Fathom keep gaining ground as the regulatory and cultural bill for surveillance-by-default comes due.
Twenty-four years is a long time to watch something refuse to sit still. The web I learned on isn't the web I work on now. Most of the tools are gone. Entire categories of expertise appeared, ran the industry, and became trivia questions.
What survives isn't the tooling. It's the orientation: every framework is temporary, every abstraction leaks, every best practice eventually files for technical-debt status, and every generation of developers eventually discovers that the thing they built their identity around is now called legacy by someone who found a YouTube channel last week. Every era ended with developers who adapted and developers who didn't, and the ones who adapted weren't smarter. They were just more willing to let go of the current thing.
I've been letting go of current things for twenty-four years. I've gotten reasonably good at it. I have a hard drive full of skills that used to pay my mortgage and now wouldn't survive a phone screen, and I've made the same kind of peace with that you make with weather.
Somewhere right now a developer is manually FTPing files to a production server. Somewhere else another is deploying globally distributed edge functions with a single git push. Both are convinced they're using the future. The second one is right. The first will figure that out eventually, and by the time she does there will already be something newer to catch up on.
The web, for its part, shows no sign of slowing down enough for any of us to get comfortable. Which is either a blessing or a curse, depending on the week.
Usually both before lunch.