The story of the first online forms: From terminals to boxes

Before the story of online forms, I want to start with the forms in general.

We very well know that writing emerges from the need for record-keeping. But there is more in the details. According to Archaic Bookkeeping by Robert Englund, Hans Nissen, and Peter, the earliest Sumerian tablets from Uruk were physically divided. Divided into "cases". These “cases” are separate boxes or cells, arranged in rows and columns. And each box, you guessed it, has numbers and other important information.

So, in essence, the first tablets were forms of that era.

Sumerian tablet from Uruk - See how it is divided into cases and had fields to fill out

(Image source: The University of Texas at Austin.Website)

This shows that collecting data, keeping records; it is a primary need, for any organization. And the history repeated itself, when the wild web first entered our lives.

I’m Salim Din, a marketer who has extensive experience in building forms. When I first joined forms.app, I was asked to do market research and present my findings. You can say, I went a bit further than that. In this article, I will share the story of the first online forms. You can find more details and resources at the end of this page.

Before online forms

The first Web server was up and running at CERN by the end of 1990 (CERN has a nice page explaining the birth of the Web. I recommend checking it out: A short history of the Web).

Before HTML and the World Wide Web, digital forms were in the form of command-line texts and email templates.

After the public use of HTML, the need for online forms was apparent. The Internet only allowed one thing, and one thing only: showing. You could read a page, you had links to other pages, and that was it. You can say, back then, the internet was read-only.

The screenshot of the first website

(Image source: CERN)

The box element before forms: ISINDEX

When Tim Berners-Lee published the first description of HTML in 1991, it listed eighteen elements.

Most of them, like P, H1, and A, were about basic structure; things we still use today. But one of them was different: ISINDEX. It told the browser that the current document was searchable, and it produced a single keyword field a visitor could type into. Type a word, hit enter, and the server would try to find a match.

It is not a form, yes, but it was the first interactive element like a form.

The first online forms

The "online form" as we know it wasn't invented in a single moment by a single person. It was assembled, piece by piece. People needed to let someone search a document, let a database talk to a web page, and find a better way to show options.

Dave Raggett’s HTML+

The real push toward something recognizable as a form came from Dave Raggett. He was an engineer at Hewlett-Packard Labs in Bristol, England, and he even visited Berners-Lee at CERN in 1992.

Raggett says he spent his nights and weekends on upgrading the HTML. He was calling it HTML+. And with HTML+ comes the form fields we know today: text fields, checkboxes, radio buttons, and selection menus.

Pei-Yuan Wei’s ViolaWWW

Around similar times, another person was working on improving the web, too; a student at UC Berkeley. Pei-Yuan Wei had released a browser called ViolaWWW in 1992 that had embedded interactive objects and, in later versions, input-style elements.

That’s why we cannot say "the first form" is created by this person or that organization. What we can say, though, is that the first forms were developed around 1992.

Forms becoming a thing with Mosaic

We talked about Dave Raggett’s HTML+ proposal. But that needed a browser willing to actually run.

That browser was NCSA Mosaic. It was a graphical browser developed by Marc Andreessen, Eric Bina, and the team at the University of Illinois's National Center for Supercomputing Applications.

Mosaic's original 1.0 release in April 1993 didn't yet support forms; that arrived with Mosaic 2.0 for X, announced on the www-talk mailing list in November 1993. The announcement explained that documents could now specify "interactive fill-out forms," rendered as a set of on-screen widgets. So, we had text boxes, toggle buttons, selection lists, and pop-up menus.

A fun fact: the same announcement uses "ordering a pizza online" as an example of what HTML forms were good for. And that foreshadows just one year later.

Where will the responses go?

The reality is that forms are just a facade. It is a pretty UI for entering text and numbers. But once you hit submit, your answers need to go somewhere.

In 1993, there was no standard way to hand off the information.

In November 1993, Rob McCool did something really cool (I know, I know), and published a draft for what he first called the "Common Gateway Protocol," then quickly renamed the Common Gateway Interface, or CGI.

CGI gave form submissions a destination. A small external program (often written in Perl) that could read the submitted data, do something with it (look it up in a database, email it, store it in a file), and return a response. McCool suggested storing these executable scripts in a folder called cgi-bin, both for organization and so server administrators could control what was allowed to run. That naming convention stuck so thoroughly that cgi-bin showed up in web addresses for the rest of the decade. And we still see it sometimes in the URLs.

Example becomes reality

Remember Mosaic’s announcement and the pizza order form example. Well…

By 1994, the form UI + CGI script was sturdy enough for a business to bet real money on it. In a trial limited to Santa Cruz, Pizza Hut launched "PizzaNet".

The first ever online order form - Pizza Hut's PizzaNet

PizzaNet was a basic web page, built with help from the Santa Cruz Operation, that let a visitor pick toppings, size, and crust from a form, type in an address and phone number, and submit an order over the internet. A Pizza Hut employee would still phone the customer to confirm everything before the pizza was made, since there was no reliable way yet to treat a web order as final. Even so, the order is widely cited by internet historians (and by Pizza Hut itself) as the first, real commercial transactions placed through a web form.

Forms becoming the standard with HTML 2.0

For its first two years, the form element existed informally. Browsers supported it because Mosaic had implemented it, and everyone copied Mosaic.

That changed in November 1995, when Berners-Lee and Dan Connolly published HTML 2.0. With the new version of HTML, FORM, INPUT, SELECT, and TEXTAREA, and tags were formally mentioned as part of the standard language.

But from what I gather in the resources and people who experienced the internet of that time, HTML 2.0 only wrote down a standard of what people agreed upon. So, we can say that Mosaic's implementation is the main driver here for forms.

The copy-paste era of forms

Once forms became a standard, another bottleneck occurred. Not everyone knew how to create forms or code in general, but everyone, or every business, wanted a contact form or a guest book. So they did the next best thing, copied from one another.

A high schooler in Colorado, Matt Wright, started Matt's Script Archive in 1995 and had a Perl script called FormMail. It was the form notifications of that day, a generic tool that took whatever a visitor submitted through any HTML form and emailed it to the site owner. And it exploded.

But it’s feature was also a vulnerability. FormMail was designed to accept arbitrary form fields and relay them by email. As you can imagine, it was eventually exploited en masse by spammers, to relay junk mail through someone else's server.

That brings us to…

The birth of form builders

Today every signup, every checkout, every survey, every login, every lead-generation page is a descendant of that original element. But businesses no longer write HTML or Perl scripts to create forms.

The entire stack, from the fields, to the validation, to the storage, to the spam filtering, to the design, is provided by form builders like forms.app.

The first form builder: FrontPage and its Form WebBot (1995)

The earliest fix for the copy-paste problem was a desktop app: FrontPage 1.0. It was released in 1995 by Vermeer Technologies, and just one year later Microsoft acquired Vermeer. FrontPage had a genuinely useful forms editor, and something called the Form WebBot: a built-in component that took whatever a visitor submitted and saved it to a file or emailed it. So no extra CGI script. For the first time, building a form and wiring up what happened after submission could both happen inside the same point-and-click tool, essentially a website builder.

Screenshot from FrontPage 1.0 in 1995

(Image source: Web Design Museum)

FrontPage didn't solve that problem elegantly. According to the programmers of that era, its auto-generated HTML was a bit… messy. But alas, it was the first time the form-building software took care of both UI and data.

Specialized forms/surveys by SurveyMonkey (1999)

The next big step came from narrowing the problem rather than solving all of it at once. In 1999, Ryan Finley built what became SurveyMonkey. While it has its quirks, it is a tool that is still in use today.

It didn't try to be a general-purpose form builder for contact pages or registrations; it went deep on question types, branching, and reporting for one well-defined job, and that focus is part of why it became, for over a decade, the default answer to "how do I survey people online."

Essentially, SurveyMonkey became a form of software that people would pay for, years before "SaaS" was a thing.

General-purpose form builders (2006)

If there's a single year that marks "form builder" becoming its own software category, it's 2006.

In Tampa, Florida, Chris Campbell, Kevin Hale, and Ryan Campbell pitched Y Combinator on an entirely different product. He suggested they build a form builder instead. Six months later, Wufoo launched.

It was hosted, it was drag-and-drop, and no HTML was required. It's commonly cited as one of the first dedicated form-building products in the industry, and it introduced features, like conditional logic in 2010, that are now considered table stakes for the category. Today, Wufoo looks dated and lacks modern form builder features, but back then, it was a category-defining product.

Google Forms enters the stage (2008)

The next shift was about the players. Google added Forms to the Google Docs suite in February 2008.

Google Forms was a basic tool, and still is, but it was just free. And people used it.

Modern form builders & forms.app (2018)

forms.app is launched by Vedat Koran and Tolga Kizilkaya in 2018 to do one thing: make the complete form builder package more accessible for teams.

There were good form builder tools at the time, but they were pricey, some essential features were lacking in all of them, and they were losing against the test of time (design and infrastructure-wise). forms.app standed out as more modern, affordable, and easier form tool.

Latest changes in form builders after AI (2021 and onwards)

Online forms first emerged over three decades ago, when our access to information had changed. Today, that access changes again with AI. forms.app and some other modern form builders started to adopt and introduce features to create forms with AI. But this is only a start and form builders will have to change again to offer better services and fix the bottlenecks, such as the time to create forms, build automations with them, and fill out the created forms.

Sources