Open-source form builder, honestly reviewed — including the part where the maintainer tells you to use something else.

TL;DR

What it is: Open-source (AGPL-3.0) form builder — think TypeForm, but self-hosted. 11 question types, embeddable forms, export to CSV/XLS/JSON, webhooks [README].
Who it’s for: Teams who want a TypeForm-style form UX without paying TypeForm prices and are comfortable managing their own server.
Key problem: The project is effectively abandoned. The README’s first paragraph explicitly tells you to use Formbricks instead — written by the maintainer, not a competitor [README].
Cost savings vs TypeForm: TypeForm Basic starts at $25/mo. Self-hosting OhMyForm costs $5–10/mo for a VPS. The math works. The software’s future does not.
Key strength: Simple deployment, decent feature set for basic form collection, PostgreSQL and SQLite support [README].
Key weakness: Actively de-recommended by its own creator. Several roadmap features (file upload, payments, encryption) were never shipped. The website redirects. No meaningful recent development [README][GitHub].

What is OhMyForm

OhMyForm started as an open-source alternative to TypeForm, TellForm, and Google Forms — a self-hosted tool for building mobile-ready surveys, questionnaires, and lead capture forms with a TypeForm-style one-question-at-a-time interface [README].

The pitch was straightforward: TypeForm charges $25–$83/month for what is, at its core, a form renderer and a database. OhMyForm gives you the same interface running on your own server, free.

At its peak the project had 2,891 GitHub stars and a working Discord community [GitHub]. The feature set covered the basics: multi-language support, 11 question types, editable start and end pages, submission export to XLS/JSON/CSV, native analytics with Google Analytics support, embeddable forms, a “Forms as a Service” API, webhook callbacks, and deployment via Heroku or Docker [README].

That was then. Today, the README opens with this: “Please try FormBricks — it’s far more feature rich and seems like it’s an ethical FOSS alternative.” And then, in the next paragraph: “We definitely endorse moving over to Formbricks at this stage. They are very much, by every measure, a vastly more advanced vision of what we would have eventually wanted to head towards ethically and feature-wise.” [README]

That is the maintainer publicly recommending a competitor. It is not common. It is unusually honest. And it is the most important fact about OhMyForm.

Why people choose it

The honest answer in 2026: most people who are choosing OhMyForm are not choosing it — they are discovering it via search, a Docker Hub listing, or an old blog post, and they do not yet know the project is in end-of-life.

The people who chose it in good faith, before the README was updated, were motivated by three things:

TypeForm’s pricing model. TypeForm charges per response on lower tiers and gates conditional logic, file upload, and API access behind higher plans. For a non-technical founder running a lead capture form or customer survey, those costs compound fast. OhMyForm offered the same conversational UI for the cost of a $5 VPS.

Data ownership. If you are collecting customer data through TypeForm, that data lives on TypeForm’s servers. Regulated industries, privacy-conscious startups, and anyone who has read a SaaS terms of service carefully enough eventually care about this. OhMyForm on your own server means your submissions never leave your infrastructure.

Simplicity over Google Forms. Google Forms is free but looks exactly like Google Forms. OhMyForm offered a TypeForm-style one-at-a-time question flow that felt more polished for external use — customer surveys, job applications, onboarding questionnaires.

None of these motivations are wrong. The product delivered on them, for a while. The problem is that the motivations are still valid but the vehicle is not.

Features

Based on the README, which represents what was actually shipped:

What works:

Multi-language UI support [README]
11 question types [README]
Editable start and end pages [README]
Export submissions to XLS, JSON, or CSV [README]
Native analytics + Google Analytics integration [README]
Embeddable forms (embed in your own site) [README]
REST API (“Forms as a Service”) [README]
Webhook callbacks on form submission [README]
Docker and Heroku deployment [README]
PostgreSQL and SQLite as database backends [README]
Customizable submission notifications [README]

What was on the roadmap and never shipped:

Custom subdomains per user [README]
Encryption for form data [README]
Typeform API integration [README]
Plugin/3rd-party integrations (Slack was mentioned) [README]
Stripe/payment form fields [README]
File upload form field [README]
Custom background images and dropdown field images [README]

That roadmap list is significant. File upload and payment processing are standard features in TypeForm’s paid tiers and in Formbricks, Tally, and every other modern form tool. They were promised, not delivered. The project stalled before it could close the gap.

Pricing: SaaS vs self-hosted math

TypeForm (the target replacement):

Free: 10 responses/month, basic question types
Basic: $25/mo (billed annually) — 100 responses/month, logic jumps
Plus: $50/mo — unlimited responses, file upload, priority support
Business: $83/mo — custom domains, Salesforce integration, advanced analytics

OhMyForm self-hosted:

Software: $0 (AGPL-3.0) [README]
VPS: $5–10/mo (Hetzner, Contabo, DigitalOcean)
Responses: unlimited
Total: ~$6/mo

The cost math is real. If you are paying TypeForm $50/mo and you have someone who can manage a Docker container, OhMyForm self-hosted saves you ~$528/year.

The catch: this only makes sense if you are confident the software will keep working. With an abandoned project, you are inheriting any future security vulnerabilities (AGPL-3.0 means the code is yours to patch, but also yours to maintain), and you will not receive new integrations or bug fixes.

Formbricks (the maintainer’s recommendation):

Free tier: self-hosted, unlimited responses, core features
Pro cloud: starts at $30/mo
Self-hosted: free and actively developed

For most use cases, Formbricks self-hosted dominates OhMyForm on every dimension — more features, active maintenance, better documentation, honest open-source governance — for the same price of a VPS.

Deployment reality check

What you need:

A Linux VPS with 1–2 GB RAM (it’s a Node.js app, not heavy)
Docker and docker-compose
A domain and reverse proxy (Caddy or nginx) for HTTPS
PostgreSQL or SQLite

The docker-compose path: OhMyForm ships a docker-compose file. For a technical user who has done this before, you are looking at 30–60 minutes from blank VPS to working forms [README]. The submodule structure requires running git submodule update --init if you pull the repository directly [README].

What can go sideways:

The website (ohmyform.com) currently redirects rather than displaying content — not a good sign for active maintenance. If the documentation hosted there goes offline, you are left with the GitHub README and whatever community posts exist.

The roadmap items that were never shipped create real deployment gaps. If your use case needs file attachments or payment collection, OhMyForm will not deliver them. You will end up bolting on separate solutions or switching tools anyway.

Security: AGPL-3.0 means you must publish modifications if you distribute the software, but it does not mean security patches will appear. An abandoned AGPL project with internet-facing form endpoints is a risk surface you own.

The Discord community exists but the signal-to-noise ratio at this stage of the project’s life is unclear.

Realistic estimate:

Technical user: 30–60 minutes to a working instance
Non-technical founder following a guide: 2–4 hours
Non-technical founder with no server experience: find someone to help, or use a different tool

Pros and Cons

Pros

Simple to understand. One purpose, clear scope — build forms, collect submissions, export data. No sprawl [README].
Genuinely free and self-hostable. AGPL-3.0, Docker-deployable, runs on commodity VPS [README].
Unlimited responses. No per-response pricing, no tier walls on submission volume [README].
PostgreSQL and SQLite support. Fits into standard infrastructure without a special database [README].
Export formats. XLS, JSON, and CSV — useful for piping data into other tools [README].
Embeddable. Can be embedded in existing sites without redirecting users to a third-party domain [README].
Multi-language. Useful for international forms [README].

Cons

The maintainer recommends you use something else. This is not a minor concern — it is the README lede [README]. Take it seriously.
Development appears stalled. GitHub metadata returned “n/a” for last commit in our data fetch. The roadmap features have not shipped [README][GitHub].
Website is non-functional. ohmyform.com redirects rather than shows documentation or product information [website scrape].
Missing features that were roadmapped. No file upload, no payment fields, no encryption, no Slack integration — all were planned, none delivered [README].
AGPL-3.0 maintenance burden. You own the security patching if you run this in production [README].
No active ecosystem. No new plugins, no third-party integrations being built, no roadmap [README].
No SSO, no audit logs, no team governance. Fine for solo use, a problem for teams [README].

Who should use this / who shouldn’t

Consider OhMyForm only if:

You already have it running and it’s working — migration cost is real, and if it ain’t broke, don’t fix it yet.
You are evaluating it as a reference implementation or educational project — the codebase is readable Node.js.
You need the absolute simplest self-hosted form builder with no ongoing subscription and your requirements are basic (text fields, multiple choice, export to CSV).

Do not use OhMyForm if:

You are starting from scratch. There is no reason to deploy a project whose own maintainer recommends an alternative.
You need file upload, payment processing, or encryption — these were never shipped.
You are building anything production-critical that depends on future bug fixes or security patches.
Your team has more than one or two people — no SSO, no governance.

Use Formbricks instead if:

You want the TypeForm-style experience, self-hosted, with active development — the maintainer’s own recommendation [README].

Use Tally if:

You want a free TypeForm alternative without self-hosting. Tally’s free tier is generous and requires zero infrastructure.

Stay on TypeForm if:

Your volume is low, compliance isn’t an issue, and you value the polish and integrations over the monthly cost.

Alternatives worth considering

The README points directly to Formbricks [README] — an actively developed, open-source form and survey platform. As of this writing it covers surveys, in-product feedback, NPS scores, and user research, with a self-hosted option under MIT license for the core components. If OhMyForm’s pitch appealed to you, Formbricks is the current answer to that pitch.

Tally — free, no-code TypeForm alternative. Closed-source SaaS but the free tier is unusually good. No self-hosting.

Typebot — open-source conversational form/chatbot builder. More powerful flow logic than OhMyForm. Actively maintained, MIT-licensed.

SurveyJS — open-source form library with a commercial dashboard. Designed to embed in your own application rather than as a standalone service. Useful if you are building a product that needs forms.

LimeSurvey — mature open-source survey platform, more enterprise-grade and complex than OhMyForm. Active development, AGPL license. Good if you need advanced survey logic and can handle the steeper setup.

Google Forms — free, no maintenance, unlimited responses. Ugly. Not self-hosted. Fine for internal use.

Bottom line

OhMyForm had a legitimate idea: TypeForm’s conversational form UI, self-hosted, free. The execution got most of the way there — Docker deployment, multi-language support, webhook integration, CSV export. For basic form collection, it works.

But the project has reached an unusual end state: the maintainer is still present enough to update the README, and that update says go use Formbricks. That level of honesty is rare and worth respecting. It also means the guidance is clear.

If you found OhMyForm while searching for a self-hosted TypeForm alternative, the answer is Formbricks for an actively maintained open-source option, or Typebot if you want conversational forms with active development. OhMyForm served its purpose and its creator is pointing you to the next generation of the same idea.

Sources

Primary sources:

GitHub repository and README: https://github.com/ohmyform/ohmyform (2,891 stars, AGPL-3.0)
Official website: https://ohmyform.com (currently redirecting)
Formbricks (maintainer-recommended alternative): https://formbricks.com

Note: Third-party review articles scraped during research for this piece returned off-topic results unrelated to OhMyForm and were excluded to avoid fabrication. Claims in this article are grounded in primary sources only.