What Web Development Was Really Like When I Started in the Late 90s

Before React, Stack Overflow, Google, and ChatGPT, my developer setup was simple: a beige Windows PC, Notepad, Internet Explorer, the occasional Netscape test, a noisy 56k modem—and a lot of patience.

I started learning web development in the late 90s. No Mac, no fancy editor, no VS Code. Just raw HTML and ASP in .txt files renamed to .html or .asp, uploaded over dial-up to free hosting.

Today, we have frameworks, DevTools, YouTube tutorials, Google, and even AI assistants like ChatGPT as our first line of help for almost any problem. Back then, things were slower, simpler, and rough around the edges

—but those early days shaped how I think about building for the web.

My Setup: Notepad, Browser, FTP, and Personal Web Server

When I was starting out, my “stack” looked like this:

• Notepad for editing .html and .asp files
• Internet Explorer, and sometimes Netscape, to test pages
• An FTP client to upload static HTML sites to free hosting
• Microsoft Personal Web Server (PWS) on Windows to run Classic ASP with MS Access databases locally

No Git. No CI/CD. No live reload. No integrated debugger.

My workflow was:

1. Open index.html or default.asp in Notepad.
2. Write or edit HTML / ASP by hand.
3. Save the file.
4. For static content: upload via FTP to a host like Angelfire, which only served HTML, images, and simple JavaScript.
5. For dynamic content: drop .asp files into wwwroot on PWS, or upload them to a free ASP host (similar to what services like Brinkster were offering back then).
6. Refresh the browser and hope I hadn’t broken everything.

If I overwrote a file on the server by accident, that was it. Unless I had my own manual backup somewhere, there was no “revert commit.” That forced me to be very conscious of every change I made.

Layouts with Tables, Spacer GIFs, and Busy Graphics

CSS existed, but support was patchy and limited. Most serious layout work was done with HTML tables.

A typical layout involved:

• A big outer table for the whole page
• Nested tables for header, sidebar, content, and footer
• Tiny spacer GIFs (1×1 pixel) stretched to control spacing in cells
• Tiled background images and bold color choices

When something broke, I didn’t have DevTools to highlight boxes or show computed styles. I debugged layouts by:

• Scanning long HTML files line by line
• Counting <tr> and <td> tags
• Fixing missing or mismatched closing tags

On top of that, I used GIFs everywhere: animated banners, buttons, icons, and little “under construction” signs. It wasn’t minimal or flat; it was noisy, but it gave the web a unique feel.

Dynamic Stuff: Applets, Classic ASP, ColdFusion, and MS Access

While a lot of people went down the CGI + Perl route, I leaned more into the Windows world.

I experimented with:

• Java applets embedded in pages for interactive widgets
• Classic ASP (Active Server Pages) running on Personal Web Server and on free ASP hosting
• ColdFusion, but only on my localhost—I played with it locally and never actually deployed it publicly
• MS Access .mdb files as my database, connected through ODBC from ASP pages

With ASP and Access, I built simple but exciting things for the time:

• Basic login forms and simple authentication
• Guestbooks and simple message boards
• Tiny CMS-style pages that pulled content from a database instead of hard-coding everything in HTML

It wasn’t scalable or “enterprise-grade,” but for someone starting out, having a dynamic, database-driven website running on a home Windows machine felt powerful.

Hosting: Static on Angelfire, Dynamic on Free ASP Hosts

My hosting experience split into two main categories:

1. Static HTML on Angelfire

For purely static sites, I used hosts like Angelfire, where you:

• Got a free subdomain
• Had a few megabytes of space
• Lived with banner ads injected into your page
• Uploaded HTML, images, and scripts via browser or FTP

This was perfect for:

• Personal homepages
• Information pages
• Layout experiments using tables and GIFs

2. Dynamic ASP on Free Windows Hosts

For Classic ASP, I used free ASP hosting providers that appeared around 1999–2000—similar to what Brinkster and other early hosts were doing:

• Classic ASP support
• Small MS Access databases or limited data storage
• A subdomain and a simple control panel
• Tight limits but enough to feel like “real hosting”

Primitive compared to modern cloud platforms, but it did the job.

The Browser Wars: Internet Explorer vs. Netscape

Even though I was on Windows, life wasn’t simple because of the browser wars between:

• Internet Explorer
• Netscape Navigator

They disagreed on how to render HTML, CSS, and JavaScript. That meant:

• A page could look perfect in IE but broken in Netscape, or the other way around
• Some tags, CSS properties, and scripts behaved differently or weren’t supported at all
• I had to test in both, compromise design, and avoid certain tricks

Those early conflicts taught me something important:

The web is not a single platform. It’s multiple engines trying to interpret the same code.

Flash, Applets, GIFs, and “Cool” Effects

If you wanted a site to feel advanced in the late 90s, you didn’t reach for React or GSAP.

You reached for:

• Macromedia Flash for intros, splash screens, animated menus, and banners
• Java applets for visual widgets or small interactive elements
• Animated GIFs for everything from buttons to logos

I used:

• Flash intros with “Skip Intro” buttons
• Simple Flash navigation bars
• Applets that did things plain HTML couldn’t
• GIFs to add motion and attention everywhere

We weren’t thinking about lighthouse scores, accessibility audits, or mobile responsiveness. We were just trying to make the site look “alive.”

The Look: Marquees, Blink, and “Under Construction”

The late-90s web had a very distinct aesthetic:

• <marquee> tags scrolling text across the page
• Blinking and flashing headlines
• Tiled background images and sometimes painful color combinations
• “Under Construction” GIFs on almost every new site
• Hit counters proudly stating: “You are visitor number 000123”

Most sites were personal—fan pages, hobby projects, journals, and link collections. They weren’t optimized for funnels or metrics; they were about having a corner of the internet that felt like yours.

How I Learned: Books, “View Source,” and Life Before Google, ChatGPT, Claude, and Codex

One of the biggest differences between then and now is how we learn.

Today, if you hit a problem, you can:

• Paste the error into Google
• Search on Stack Overflow
• Ask ChatGPT or Claude to explain it
• Use AI coding tools built on Codex to suggest fixes
• Watch step-by-step tutorials on YouTube

When I started, that ecosystem simply didn’t exist.

• Google wasn’t yet the automatic first stop for every question.
• Stack Overflow didn’t exist.
• AI assistants like ChatGPT, Claude, and Codex-based tools were unimaginable.

So I learned from:

• Programming books—the classic series and publishers of that era:
• Sams Teach Yourself books (like Teach Yourself HTML in 24 Hours, ASP, etc.)
• Wrox Press titles like Beginning ASP with their iconic red covers and developer photos
• O’Reilly books with animal covers that became staple items on every dev’s shelf
• Big Que “Using HTML” / “Special Edition” books packed with examples
• Early web tutorials scattered across random websites
• And my favorite teacher: Right-click → View Source

My learning loop looked like this:

1. Read a chapter in a book about a tag, a piece of ASP, or a database trick.
2. Try it in Notepad.
3. Refresh in the browser and see what happens.
4. If I found a cool site, I’d view the source, copy a snippet, and reverse-engineer it.

Without Google, ChatGPT, Claude, Codex, and Stack Overflow to instantly answer everything, I had to sit with problems longer, experiment more, and actually read documentation and books. It was slower, but it made the fundamentals stick.

Comparing Then and Now

Looking back from today, the contrast is huge.

Back then:

• Notepad as the “IDE”
• Table-based layouts and spacer GIFs
• Classic ASP + MS Access on Personal Web Server
• Flash intros, Java applets, and animated GIFs
• Static HTML on Angelfire, dynamic ASP on free Windows hosts
• Learning from thick books and “View Source,” not from Google and AI tools

Now:

• VS Code, JetBrains, and powerful editor ecosystems
• Flexbox, CSS Grid, responsive design
• Frameworks like React, Vue, Svelte, Next.js
• Databases, clouds, containers, CI/CD, and observability tools
• Google, Stack Overflow, YouTube tutorials
• AI copilots like ChatGPT, Claude, and Codex-based tools helping write and understand code

Even with all the modern tools and shortcuts we have today, I still appreciate that late-90s era. It was clunky and full of limits, but it forced me to understand the fundamentals—HTML, HTTP, servers, databases, and browsers all meeting in the middle.

And honestly, that hasn’t changed:

Give me a text editor, a server, and a browser—and even in a world with ChatGPT, Claude, and Codex—I’m still happy to build.