• 

• 

• 

• 

• 

Inspiration

I kept running into the same problem with existing form builders. Google Forms is free, but it can't handle real branching logic. Tools like Typeform and Tally support conditional flows, but once responses start coming in, you're still left interpreting dashboards yourself.

I realized that building a form and understanding its results are really the same problem - yet every product treated them as separate workflows. Most "AI" features felt like chatbots bolted onto traditional form builders rather than systems that actually understood how forms work.

I decided to build the product I wished already existed.

What it does

Pollaris is an AI-native survey and form platform built around two ideas intelligent form generation and meaningful analysis.

Instead of manually creating questions, users simply describe what they want to learn in plain English. Pollaris generates a real branching survey represented as a directed graph of questions and conditional paths, not just a linear questionnaire.

Once responses start arriving, Pollaris provides two complementary layers of insight.

Analytics

Rather than showing a simple response count, Pollaris computes analytics that actually understand branching forms.

It includes:

• Per-question drop-off calculated from each respondent's actual traversal path instead of assuming a single linear funnel.
• Audience segmentation by device, browser, operating system, language, screen size, referrer, and UTM parameters.
• Average time spent on every question.
• A weekday × hour heatmap showing when respondents arrive.

AI Reports

On top of the computed analytics, Pollaris generates a natural-language report explaining what the numbers actually mean.

The AI never performs the calculations itself every metric is produced deterministically by the backend first, and the model only interprets the aggregated results.

That separation keeps every insight explainable and trustworthy.

How I built it

Pollaris is built with FastAPI and PostgreSQL, centered around one core abstraction — FormDefinition.

Every form is represented as a graph where questions are nodes and conditional transitions are edges.

Everything in the system speaks this same language.

• The manual form builder produces a Form Definition. (From Definations is the Heart of the directed graph in the project)
• The AI form generator produces a Form Definition.
• The runtime engine reads it to guide respondents through the survey.
• The validator checks it before publishing.
• The analytics pipeline aggregates results from it.
• The AI reporting system summarizes those results.

Because every component shares the same contract, AI isn't an add-on feature it's simply another producer of valid forms.

To make AI generation practical, we (I and AI) designed a lightweight Mermaid-inspired DSL that lets an LLM describe surveys as readable text instead of hand-writing large JSON graphs.

The compiler automatically generates question IDs, connects default transitions, and validates the resulting graph before publication.

The validator catches problems such as:

• Dead ends
• Missing branch coverage
• Unreachable questions
• Cycles

The analytics engine uses that same graph structure.

Since branching surveys don't have a single ordered sequence, every metric is calculated from each respondent's actual traversal path rather than relying on a global denominator.

---

Challenges I ran into

The hardest part was designing the graph architecture.

I wanted Form Definition to be correct by construction simple linear surveys should require almost no manual configuration, while more complex branching flows should still guarantee reachability, complete branch coverage, and valid navigation.

That same complexity appeared again when building analytics.

A traditional drop-off funnel assumes every respondent follows the same sequence of questions. Branching surveys break that assumption completely, so I had to rethink how engagement metrics should be calculated.

Building all of that while delivering a polished end-to-end MVP in just one week meant constantly balancing architectural correctness against shipping new features.

---

Accomplishments I am proud of

I am especially proud of building a single graph architecture that every part of the platform shares.

Instead of maintaining separate representations for AI generation, runtime execution, analytics, and reporting, everything works from one common contract.

I also successfully built an end-to-end AI pipeline where users can generate surveys with AI, collect responses, analyze them, and receive AI-written reports based entirely on deterministic analytics.

On top of that, I built analytics that genuinely understand branching surveys instead of pretending every survey is linear.

Completing authentication, workspaces, the graph engine, the DSL, publishing, response collection, analytics, and AI reporting in a usable MVP within one week was something I am incredibly proud of.

---

What I learned

The biggest lesson was that investing early in the right data model paid off throughout the project.

Representing forms as graphs with one shared contract meant every new feature naturally became another producer or consumer of FormDefinition instead of introducing another special case.

That architectural decision made AI generation, validation, analytics, and reporting fit together naturally instead of competing with one another.

Also learned how to use tools like Codex and Calude Code effectively to make the MVP to production ready project

---

What's next for Pollaris

Our immediate roadmap includes:

• Plan-based billing enforcement
• AI-generated follow-up questions for open-ended responses
• Theme and sentiment analysis across survey results

Beyond that, I am excited about something much bigger — agent-native form creation.

Today, if you ask an AI agent to create a customer feedback survey, it usually can't complete the task end-to-end because existing form APIs are designed for humans clicking through interfaces rather than machines authoring structured forms.

Pollaris is different.

Because forms are represented as validated graphs through a shared Form Definition contract, we're in a position to expose that capability through an MCP server.

That would allow AI agents like ChatGPT or other LLMs to generate complete, valid branching surveys programmatically. A human would simply review and approve the form before publishing.

It's the natural evolution of our original vision moving from AI helping people build forms to AI agents creating production-ready forms autonomously.

Built With

• fastapi
• llm
• postgresql
• vite