Web 1.0: Gen X, HTML, and the Text-Based Internet

In the booming ’90s, as Reality Bites and Friends dominated a certain segment of mainstream American culture, personal computers and Internet technology gave rise to the Web. We’ve already written extensively about the rise of 90s computer networking, so we won’t talk much about those dynamics (except for re-posting, for the thousandth time, my favorite video from that era). But we will take a moment to discuss the specific mechanics underlying web development at the time.

There are a number of great websites from the ’90s saved by Archive.org’s Wayback Machine (Quick Tangent: A large number have not been archived, something that has led folks to describe the age we’re living in as a “dark age” of the internet), so it was a treat deciding which one to pick (First Craigslist Archive?). We settled on Yahoo’s homepage, as it was one of the most popular at the time.

Why does this website look so adorable from our vantage point many decades later? Well, it’s a text-based document that is being read by the browser, then rendered. No video ads, no moving parts, no “like” buttons to click.

This is basic HTML, or HyperText Markup Language, the first language of the World Wide Web. It’s a simple document that’s relatively easy to read, even for non-technical folks. It’s structured in a clear way and, when we grab the source code and pair it with their respective renderings, it’s not terribly intimidating.

The source code for this website is a teensy 10KB. (For comparison’s sake, Yahoo’s 2019 website source code is 6,940% larger at a whopping 694KB, not including external libraries.) 1996 Yahoo.com is basic, clean, and clear––and super exciting for the time! Yahoo’s IPO had just occurred in April 1996 and on the first day, the price had spiked to $1.6B in today’s dollars. Based on this website! So, for context, this was considered cutting-edge for 1996.

From our 2019 perspective, 1996 Yahoo.com is simple (some might even say, boring). But you know how these Gen Xers are, right? They got super stoked about a silly commercial they watched on an actual television. What about the generation just after them, though? Those kids who can’t sit still for more than three minutes? How are we gonna keep them glued to the screen?

Web 2.0: Millennials, User-Generated Content, and the Rise of State

The 1990s web experience wasn’t gonna cut it for millennials, that’s for sure. Instead, that generation ushered in what’s commonly called Web 2.0. Like all terms invented by Silicon Valley, it’s vague, but it essentially captures a few different changes ushered in by the rise of social media like Facebook and Twitter:

  • In Web 1.0, the users of a website consumed information, but in Web 2.0, the users create information to be shared and consumed by others.

  • The user-generated information from Web 2.0 came from social media websites like Facebook and Twitter.

  • Popular websites now delivered personalized content, and received individualized updates, rather than simply presenting the user with a static HTML document.

The Web 2.0 paradigm shift moved a document-based, link-based web experience (in which websites are text documents) to interactive websites, like Facebook or Twitter, with user-generated and user-specific content (my Facebook profile looks different from yours).

Many people have written about this shift from a behavioral and consumer perspective, i.e. how social media changed the way we interact with and consume information in the world. What’s less talked about is how this shift precipitated a reworking of the essential nature of the internet––a shift that also holds the key to understanding the promise of Ethereum and Web 3.0.

Social media sites require a tremendous amount of computation and coordination. When you look at Twitter, for example, the website has to immediately serve all the content specific to your profile. It then has to register anything you do on the site––posting, liking, clicking––and relay that to its servers. Imagine that exhausting roundabout multiplied by however many millions (or billions!) of users on a platform, all interacting with each other and a website simultaneously.

For a long time, engineers simply bolted this processing onto the back of static sites. Web 1.0’s document-based template creaked and groaned under the mounting weight of Ajax, a broad term describing these new trends of Web 2.0 development.

It was getting precarious. An engineer described his schedule at Facebook in the early days: to make sure TheFacebook.com didn’t crash despite constant updates, he would “drink a large glass of water before I went to sleep to assure that I’d wake up in two hours so I could go check everything and make sure that we hadn’t broken it in the meantime. It was all day, all night.”

All these sites continued to gain users by the thousands, which only added to the pressure. Active users needed more features, faster load times––things were only getting more complex as more users joined these platforms. In search of a solution, engineers began circling around a concept that would transform web development.


State can be defined as a set of variables describing a certain system at a specific time. Let’s describe that in a real-world situation. Take a look around at whatever environment you’re in––bus station, coffee shop, office––and pick out a few variables you could use to describe it. If you’re inside a room, you could describe any number of things:

  • The number of walls

  • The types of furniture

  • The placement of furniture

  • The number of people

  • The kind of light in the room

The more variables we have, the clearer the picture of the room becomes in our minds, yes? And, if something minor changes in the environment (someone leaves the room, for example) we don’t have to describe everything in the room all over again. We just update the specific variables affected by the change and leave the other variables alone.

Working with the document model of Web 1.0, a browser had to effectively create a new document every time an update occurred on a website, no matter how minor. This created bottlenecks when minor updates were happening millions of times per second across the network. Engineers realized they could alleviate the problem by separating web development into two parts: the HTML template of a site and the state describing what goes into the template.

The HTML template would be the basic outline of the site and would look the same for all users—the site’s logo, the general layout, the color scheme. The user-specific state would fill in that outline, providing a description of the environment specific to that user—their profile, their friends, their favorite posts, etc. Crucially, if something in the state changed, all the browser had to do was find the parts of the structure affected and update them. No more massive page reloads.

This model of an HTML template and its state is known as a framework. Different Web 2.0 groups have produced their own frameworks, two popular ones being React (built by Facebook) and Vue (built by Google). [Note to people scoffing right now: I know React is a library, just the “V in the MVC.” This framework classification is purposeful to make a larger point.] Frameworks shoehorned Web 2.0 dynamics into the Web 1.0 slot and allowed sites like Facebook to extend themselves further. The framework model takeover of web development has been dramatic not only in its totality but also in its virtual invisibility to the general public.

Often, non-technical folks may hear about the current need in tech companies for front-end developers. Those are people that can build websites on frameworks like React or Vue. Less often do these same companies need HTML developers, a viable job fifteen years ago. In fact, the framework developer’s lingo doesn’t really include the term “website” anymore. Instead, developers talk about building “web apps.”

The domination of frameworks has brought a paradigm shift in the way we experience the Internet. Previously, we depended on browsers to access social media. Now, with frameworks, it’s actually easier to deliver state to an app, not only for capturing and monitoring users, but also in terms of optimizing performance for mobile phones, which became a major access point for many users. While Millennials grew up “surfing the web” (falling down Wikipedia rabbit holes, clicking through links for ages), the browsing experience now is more platform-oriented. We’ve been herded from the wild west of websites, fenced in by platforms to the more predictable gardens of apps.

Web 3.0: Gen Z and the Battle for State

Let’s start with a few definitions. The term “Web 3.0” can be defined as a movement to connect and relate data in a machine-readable way. Tim Berners-Lee envisions this shift in terms of the Semantic Web and blockchain guru John Wolpert sees it in terms of the Stateful Internet. For the purposes of this article, we’ll define blockchain as a way of creating, securing, and maintaining state data without relying on a single, centralized point of truth.

The term “Gen Z” describes a generation born from the mid-90s to mid-00s which, in certain classes or regions, has known only a world with the internet and smartphones. The vast majority of this generation is platform-native—they grew up and interact primarily with state-based apps.

In the previous section, we saw how the state-based apps overcame Web 1.0 bottlenecks, but the model also has a powerful secondary effect. State changes, major and minor, collected over time, can begin to paint a very detailed picture of the individuals making them. What you clicked, when you clicked it, what you first looked at when you logged on, the last thing you saw before you logged off: all of these states unfurl like a film reel to assemble an intimate view of you as a user.

How intimate? You’ve probably heard the urban legend of a friend having an in-person conversation and, later, something they mentioned shows up as an ad in their Facebook feed. People across the Internet are convinced they’re being spied upon. However, researchers studied the issue for a year and have proven this is not actually happening. This shouldn’t comfort you, though. Because it implies an even darker truth: Facebook has collected enough connected information about certain users, in such a granular, specific way, that it can predict what they will think or want to buy––it doesn’t have to listen to your conversations to know.

They certainly have the data. Facebook has an enormous user base of about 2 billion people, and a wide array of services from which it can harvest user information. Since Facebook is a company whose business model depends primarily on advertising sales, they have created a rich database of interconnected individual information. Not only do they model your individual behavior, they also link that behavior to your friends’ behaviors. These connections compound the analytic power Facebook has. It is Facebook’s own, internal Web 3.0, a “stateful internet” put together in a system they call the Social Graph or sometimes just the Graph. It’s such an effective targeting tool for advertising that Facebook made $40B in revenue in 2017, almost 90% coming from advertising.

What’s so bad about that? We could outline the number of different controversies Facebook has precipitated over the past few years, from data breaches to wrecking public discourse. But for the sake of this argument, let’s focus on data sovereignty: who owns the data that describes your behavior?

The obvious answer should be you. However, it should be clear by now that the trajectory of web development over the past few decades has created an environment in which your data does not belong to you. The development of state collected on platforms, initially meant to optimize performance, has also stored the state changes on whichever company’s server that platform runs on.

Whose Data?

Blockchain’s version of Web 3.0 is one in which state is not siloed on a single platform, nor stored on a single server. Instead, a global state is maintained on an open and distributed network secured through decentralized methods. Everyone can view and verify the state of the network at any time. People on that network are not necessarily there for an idealistic purpose––a strong blockchain network assumes that no one can be trusted and therefore delegates trust to cryptographic tools.

Web 3.0 allows a global commons for state. Rather than state (meaning our data) being held by companies, we create a decentralized network where trust is established at the protocol level. It comes from mathematics and cryptography baked into the protocol. The protocol is broadly called blockchain, but it has different implementations. Just like you can have different operating systems on your phone (Apple or Android), there exist different blockchain protocols, such as Ethereum or Bitcoin.

Each blockchain carries its own assumptions about network participants and unique protocol features, but all emphasize the individual’s ownership of data. This means that blockchain data is a public commons and only you can alter your own data. What’s the practical impact of this theoretical statement? Let’s explore the idea with an example: a dramatic example involving global finance.

In our initial discussion of state, we used the example of describing a room. It’s a simple description with very little at stake—no one is going to buy our hypothetical room, we’re just talking about it. However, if someone did want to buy this room, the situation changes. They would want to check our state description, i.e. see the room for themselves, and we would want to make sure they really had enough money to purchase it. For checking a state like this––confirming if someone does have enough money to pay for an item––we created a trusted third party: banks. Today, to validate someone’s financial state, the room seller can simply swipe a credit card, which effectively asks a bank if the buyer has enough money to buy.

Blockchains like Bitcoin and Ethereum allow people to conduct financial exchanges digitally and almost instantaneously, today, without banks. They do this by creating the global state that is secured not through social trust (accrued over hundreds of years to the third party institution of banks), but in code, through a protocol. In the same way we no longer have to speak to an operator to connect a phone call, blockchain makes financial transactions into a peer-to-peer protocol. Crucially, though, the protocol is decentralized and distributed––involving a global, public chain secured by the entire network of people running it.

Gen Z seems incredibly motivated to solve serious political, economic, and social issues. More importantly, they seem to be doing it with less regard for convention or tradition. Blockchain advocates believe a public Web 3.0 will repair some of the biggest problems in the current closed system implemented and exploited by large Web 2.0 tech companies. The recent privacy scandals at corporations such as Facebook and Google show the dark side of this siloed knowledge––and the outsized fortunes they’ve earned by selling users’ data, while also failing to protect it.

And these breaches have pushed well beyond the realm of digital technology. An open, agreed-upon-by-all state, or “truth,” is nearly impossible to find in our general public discourse. The gears of our politics have been jammed with the sand of miscommunication, fake news, and blatant lying. One writer described it as “a fracturing of factual consensus.” It is one of the major obstacles facing Gen Z’s fight for social justice.

That the current systems transformed large swaths of society and the essential ways humans interact is inarguable: the social experience of Gen X and Gen Z could hardly be more different even though just 20 years divide them. But what began as an amazing leap forward for global communication and information access with the advent of Web 2.0, has resulted in a dramatic information asymmetry between platforms and their users. This has implications for major world events, such as elections, mass protests, and revolutions.

The builders of Web 3.0 and blockchain systems, at their core, aim to rebalance this asymmetry of power by way of open state. This doesn't necessarily mean that all the problems of the Web will be magically fixed; no technology alone can do that. But by re-establishing trust online, perhaps we can get closer to realizing the initial promise of the Web. What happens next will be decided by the next generation of builders.

Want more blockchain explainers?

Subscribe to our newsletter to get our latest blockchain tutorials, webinars, resources, and more straight to your inbox.