Don’tTypeTheForm

Forms made for humans, not databases.

Comment

Inspiration

Most forms are built for databases, not people.

They force users to click through fields, understand labels, choose from rigid dropdowns, and translate what they want to say into the structure a system expects.

We started Don’tTypeTheForm with a simple question:

Why should people fill out a form when they could just explain what they need?

We wanted to build a form experience that feels natural and human. One where users do not have to think about fields or data structures. They simply have a conversation, while the system quietly identifies and structures the information behind the scenes.

What it does

Don’tTypeTheForm replaces traditional forms with adaptive conversations.

Instead of navigating through input fields, users answer naturally in their own words. The system understands what they have already shared, identifies missing or unclear information, and asks only the follow-up questions that are actually necessary.

Once the conversation is complete, Don’tTypeTheForm transforms it into clean, structured, and actionable data.

This means:

  • No long pages of fields
  • No repetitive questions
  • No confusing dropdowns
  • No rigid question paths
  • More context-rich answers
  • Structured data without making users feel like they are entering data

The form adapts to the person, instead of forcing the person to adapt to the form.

How we built it

We designed Don’tTypeTheForm around two connected layers.

The first is a conversational interface where questions are presented naturally, one at a time. The experience is designed to feel closer to speaking with someone than completing a traditional form.

The second is an AI-powered reasoning layer. After each answer, the system evaluates:

  • What information has already been provided
  • Whether the answer is sufficiently complete
  • Which required details are still missing
  • Whether a clarification is necessary
  • What the most relevant next question should be
  • Whether the conversation can finish

The collected information is then converted into structured data that can be reviewed, exported, or connected to other workflows.

We also built support for fixed-question forms when every respondent must receive exactly the same questions, while preserving the same conversational experience.

Challenges we ran into

The biggest challenge was making the experience feel like a focused form rather than an open-ended chatbot.

A conversational form must understand when to continue, when to clarify, and when to stop. Asking too few questions creates incomplete data, but asking too many makes the experience frustrating.

To solve this, we created rules around answer completeness, ambiguity, required information, question limits, and conversation depth.

Another major challenge was converting natural language into reliable structured data. People rarely answer using the exact terminology or format expected by a database. The system needed to preserve the meaning and context of each answer while producing consistent output.

We also had to prevent repeated questions. Users often provide several pieces of information in a single message, so the system must recognize what has already been answered before choosing the next question.

Accomplishments that we're proud of

We are proud that Don’tTypeTheForm does more than place a chatbot interface on top of a traditional form.

The conversation genuinely adapts to each person. Two users can complete the same form through completely different paths, depending on the information they provide.

We are also proud that the platform can turn unstructured conversations into clean, usable data without exposing the underlying complexity to the respondent.

Most importantly, we created an experience where people can focus on what they want to communicate instead of thinking about how a database expects them to communicate it.

What we learned

We learned that replacing fields with a chat interface is not enough.

The real value comes from reducing the cognitive effort required to complete a form. A good conversational form should understand context, avoid unnecessary questions, and respect the user’s time.

We also learned that the smartest conversation is not the one that asks the most questions. It is the one that asks the fewest questions necessary to understand the person correctly.

Finally, we learned that natural conversations often produce richer and more useful information than traditional fields, because people can explain context instead of compressing their answers into predefined boxes.

What's next for Don’tTypeTheForm

Our next step is to turn Don’tTypeTheForm into a complete alternative to traditional form builders.

We plan to introduce:

  • Reusable form templates
  • Embeddable conversational forms
  • Multilingual conversations
  • Advanced response analytics
  • Team collaboration
  • Workflow automations
  • Webhooks and third-party integrations
  • Deeper personalization based on previous answers
  • Multiple conversational depth modes
  • Better tools for reviewing and exporting structured responses

Our long-term vision is to make filling out forms feel obsolete.

Forms made for humans, not databases.

Built With

Share this project:

Updates