Best Self-Hosted Form Builders & Survey Tools 2026

Collecting data through forms and surveys is one of the most common tasks for businesses, developers, and organizations. The dominant players — Google Forms, Typeform, Jotform, and SurveyMonkey — all share the same fundamental problem: your respondents’ data lives on someone else’s servers. For privacy-conscious teams, GDPR-compliant organizations, or anyone who values data sovereignty, this is a non-starter.

Self-hosted form builders give you full control over every response, every piece of metadata, and every integration. In 2026, the open-source ecosystem has matured to the point where self-hosted solutions rival — and in some cases exceed — their commercial counterparts in features, design, and flexibility.

This guide compares the best self-hosted form builders and survey platforms available today, with hands-on deployment instructions for each.

Why Self-Host Your Forms and Surveys

The reasons to move away from SaaS form builders go beyond simple privacy preferences:

Data ownership and compliance. Regulations like GDPR, HIPAA, and CCPA place strict requirements on how personal data is collected, stored, and processed. When you self-host, the data never leaves your infrastructure. You control retention policies, encryption keys, and access controls — no third-party vendor to negotiate with or audit.

No response limits or paywalls. Free tiers of Google Forms and Typeform cap you at a handful of forms or a few hundred responses per month. Paid plans scale into hundreds of dollars annually. Self-hosted tools have no artificial limits — collect ten responses or ten million, the only constraint is your server capacity.

Custom integrations without vendor lock-in. Commercial platforms offer integrations, but they are curated and often require premium plans. Self-hosted solutions expose raw APIs, webhooks, and database access, letting you build custom pipelines to your existing infrastructure — your CRM, your data warehouse, your notification system.

Branding and white-labeling. Remove all third-party branding. Embed forms that look like they were built in-house. Custom domains, custom CSS, and full control over the user experience from the first click to the thank-you page.

Offline and air-gapped deployments. Some organizations operate in environments with no internet access or strict network segmentation. Self-hosted form builders can run entirely on-premises, collecting data in disconnected environments and syncing when connectivity is restored.

Top Self-Hosted Form Builders Compared

Formbricks — Open-Source Experience Management

Formbricks is the newest and most ambitious entrant in the self-hosted form space. Originally built as an open-source alternative to Hotjar and Typeform, it has evolved into a full experience management platform. It supports in-app surveys, website pop-ups, multi-step forms, and link-based surveys — all with a modern, polished interface.

Key features:

• Multi-step forms with conditional logic and branching
• In-app and on-site survey widgets
• Link-based surveys (Typeform-style single-question-per-screen)
• Real-time response analytics and dashboards
• API-first architecture with comprehensive REST endpoints
• Built-in A/B testing for form optimization
• GDPR-compliant out of the box (no tracking cookies by default)
• Webhook integrations and native connections to Slack, Notion, and n8n

Best for: Product teams, UX researchers, and SaaS companies that need in-app surveys and experience tracking alongside traditional form collection.

NocoDB / Baserow Forms — Database-Native Forms

NocoDB and Baserow are open-source Airtable alternatives that include form-building capabilities tied directly to their database backends. When someone submits a form, the response lands as a row in your database table — no middleware, no syncing, no API calls to bridge the gap.

Key features:

• Forms are views on database tables — responses are stored natively
• Drag-and-drop form designer with field type validation
• Conditional display rules and required field enforcement
• File upload fields with configurable storage backends
• Automatic email notifications on new submissions
• Shareable form URLs with optional access controls
• REST and GraphQL APIs on every table/form

Best for: Teams already using NocoDB or Baserow as their operational database, or anyone who wants form responses to flow directly into a structured data store.

OhMyForm — Community Survey Platform

OhMyForm is a dedicated open-source survey and form builder focused on simplicity and community-driven development. It supports a wide variety of field types and is designed specifically for surveys, questionnaires, and registration forms.

Key features:

• Rich field types: text, number, date, dropdown, radio, checkbox, file upload, matrix
• Multi-page forms with progress indicators
• Themeable form templates with custom CSS support
• Response export to CSV and JSON
• Anonymous response collection with optional respondent identification
• Community-driven plugin ecosystem
• Lightweight resource requirements

Best for: Community organizations, nonprofits, and academic researchers running surveys with diverse question types.

LimeSurvey — Enterprise Survey Engine

LimeSurvey is the veteran of open-source survey platforms. With over 20 years of development, it is the most feature-complete survey tool in the open-source ecosystem. It is used by universities, governments, and enterprises worldwide for large-scale data collection.

Key features:

• 30+ question types including array, ranking, equation, and multiple-short-text
• Advanced branching and skip logic with complex condition expressions
• Quota management to cap responses per group
• Built-in participant/token management for controlled surveys
• Multi-language survey support with automatic translation workflows
• Statistical analysis tools and cross-tabulation reports
• Extensive theming engine with Twig templates
• LDAP/AD integration and SSO support

Best for: Academic researchers, government agencies, and enterprises running complex, multi-language surveys with advanced logic requirements.

Fider — Open-Source Feedback Platform

Fider takes a different approach: instead of traditional forms, it provides an open-source platform for collecting and prioritizing user feedback and feature requests — an alternative to Canny and UserVoice. Users post ideas, others vote, and your team triages and responds.

Key features:

• Public feedback boards with voting and commenting
• Status tracking (Planned, Started, Completed, Declined)
• Email notification workflows for status changes
• Private teams and internal-only boards
• Custom domain support with SSL
• REST API for integrations
• Lightweight single-binary deployment

Best for: Product teams collecting feature requests and community feedback in a structured, transparent way.

Feature Comparison Table

Docker Deployment Guides

Deploying Formbricks

Formbricks provides an official Docker Compose setup that includes PostgreSQL and the Formbricks application server:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# docker-compose.formbricks.yml
version: "3.8"

services:
  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      POSTGRES_USER: formbricks
      POSTGRES_PASSWORD: ${DB_PASSWORD:-formbricks_secret}
      POSTGRES_DB: formbricks
    volumes:
      - formbricks_postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U formbricks"]
      interval: 10s
      timeout: 5s
      retries: 5

  formbricks:
    image: ghcr.io/formbricks/formbricks:latest
    restart: always
    ports:
      - "3000:3000"
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      DATABASE_URL: "postgresql://formbricks:${DB_PASSWORD:-formbricks_secret}@postgres:5432/formbricks?schema=public"
      NEXTAUTH_SECRET: ${NEXTAUTH_SECRET:-change_this_to_a_random_32_char_string}
      NEXTAUTH_URL: "http://localhost:3000"
      ENCRYPTION_KEY: ${ENCRYPTION_KEY:-change_this_to_a_random_32_char_string}
      CRON_SECRET: ${CRON_SECRET:-change_this_to_a_random_32_char_string}

volumes:
  formbricks_postgres_data:

Start the stack:

1
2
3
4
5
6
7

# Generate secure secrets
export DB_PASSWORD=$(openssl rand -base64 32)
export NEXTAUTH_SECRET=$(openssl rand -base64 32)
export ENCRYPTION_KEY=$(openssl rand -base64 32)
export CRON_SECRET=$(openssl rand -base64 32)

docker compose -f docker-compose.formbricks.yml up -d

After the containers are running, open http://localhost:3000 to create your admin account and start building forms. For production, add a reverse proxy with TLS termination:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

server {
    listen 443 ssl http2;
    server_name surveys.example.com;

    ssl_certificate /etc/letsencrypt/live/surveys.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/surveys.example.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Deploying NocoDB with Form Support

NocoDB runs with either SQLite (quick start) or PostgreSQL (production):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# docker-compose.nocodb.yml
version: "3.8"

services:
  nocodb:
    image: nocodb/nocodb:latest
    restart: always
    ports:
      - "8080:8080"
    environment:
      NC_DB: "pg://postgres:5432?u=nocodb&p=nocodb_pass&d=nocodb"
      NC_REDIS_URL: "redis://redis:6379"
      NC_PUBLIC_URL: "https://forms.example.com"
      NC_SMTP_HOST: "smtp.example.com"
      NC_SMTP_PORT: 587
      NC_SMTP_USERNAME: "noreply@example.com"
      NC_SMTP_PASSWORD: "${SMTP_PASSWORD}"
      NC_SMTP_SECURE: "true"
    depends_on:
      - postgres
      - redis
    volumes:
      - nocodb_data:/usr/app/data

  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      POSTGRES_USER: nocodb
      POSTGRES_PASSWORD: nocodb_pass
      POSTGRES_DB: nocodb
    volumes:
      - nocodb_pg_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    restart: always

volumes:
  nocodb_data:
  nocodb_pg_data:

1

docker compose -f docker-compose.nocodb.yml up -d

Once running, visit http://localhost:8080, create a new project and table, then click the “Form View” icon to design your form. Each table can have multiple form views with different field selections and layouts.

Deploying LimeSurvey

LimeSurvey provides an official Docker image with Apache:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# docker-compose.limesurvey.yml
version: "3.8"

services:
  limesurvey:
    image: acspri/limesurvey:6-apache
    restart: always
    ports:
      - "8081:8080"
    environment:
      ADMIN_USER: admin
      ADMIN_NAME: "Survey Administrator"
      ADMIN_PASSWORD: ${LS_ADMIN_PASSWORD:-admin123}
      DB_TYPE: "mysql"
      DB_HOST: "mysql"
      DB_PORT: 3306
      DB_NAME: "limesurvey"
      DB_USERNAME: "limesurvey"
      DB_PASSWORD: ${LS_DB_PASSWORD:-limesurvey_secret}
    depends_on:
      mysql:
        condition: service_healthy
    volumes:
      - limesurvey_plugins:/var/www/html/plugins
      - limesurvey_themes:/var/www/html/upload/themes
      - limesurvey_surveys:/var/www/html/upload/survey

  mysql:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-root_secret}
      MYSQL_DATABASE: limesurvey
      MYSQL_USER: limesurvey
      MYSQL_PASSWORD: ${LS_DB_PASSWORD:-limesurvey_secret}
    volumes:
      - limesurvey_mysql_data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  limesurvey_plugins:
  limesurvey_themes:
  limesurvey_surveys:
  limesurvey_mysql_data:

1
2
3
4
5

export LS_ADMIN_PASSWORD=$(openssl rand -base64 24)
export LS_DB_PASSWORD=$(openssl rand -base64 24)
export MYSQL_ROOT_PASSWORD=$(openssl rand -base64 24)

docker compose -f docker-compose.limesurvey.yml up -d

Access the admin panel at http://localhost:8081/admin. LimeSurvey will guide you through the initial setup wizard on first launch.

Deploying Fider

Fider is the simplest to deploy — it is a single binary with SQLite or PostgreSQL:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# docker-compose.fider.yml
version: "3.8"

services:
  fider:
    image: getfider/fider:stable
    restart: always
    ports:
      - "3000:3000"
    environment:
      BASE_URL: "https://feedback.example.com"
      DATABASE_URL: "postgres://fider:fider_pass@postgres:5432/fider?sslmode=disable"
      JWT_SECRET: ${JWT_SECRET:-change_this_secret}
      SMTP_HOST: "smtp.example.com"
      SMTP_PORT: 587
      SMTP_USERNAME: "noreply@example.com"
      SMTP_PASSWORD: "${SMTP_PASSWORD}"
      SMTP_ENABLE_STARTTLS: "true"
      MAILER_NOREPLY_NAME: "Feedback Team"
    depends_on:
      postgres:
        condition: service_healthy

  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      POSTGRES_USER: fider
      POSTGRES_PASSWORD: fider_pass
      POSTGRES_DB: fider
    volumes:
      - fider_pg_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U fider"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  fider_pg_data:

1
2
3

export JWT_SECRET=$(openssl rand -base64 32)

docker compose -f docker-compose.fider.yml up -d

Visit http://localhost:3000 to sign up as the first user — that account automatically becomes the site administrator.

Integration Patterns

Webhook Pipeline with n8n

For advanced workflows, connect your form submissions to n8n for automated processing:

1
2
3
4
5
6
7
8
9

# In your form builder, configure a webhook pointing to:
# http://n8n.example.com/webhook/form-submission

# Example n8n workflow triggered by form submission:
# 1. Webhook node receives the POST data
# 2. Split node checks: is this a support request or a survey?
# 3a. If support: create ticket in your issue tracker
# 3b. If survey: append row to your analytics database
# 4. Send confirmation email to the respondent

Direct Database Access

When your form builder stores responses in PostgreSQL or MySQL (like NocoDB or LimeSurvey), you can query them directly:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

-- Count responses per day for the last 30 days
SELECT DATE(submitdate) as day, COUNT(*) as responses
FROM lime_survey_12345
WHERE submitdate >= DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY DATE(submitdate)
ORDER BY day DESC;

-- Average satisfaction score by region
SELECT 
    `0region` AS region,
    AVG(CAST(`0satisfaction` AS DECIMAL(5,2))) AS avg_score
FROM lime_survey_12345
WHERE submitdate IS NOT NULL
GROUP BY region;

Embedding Forms in Existing Sites

Most self-hosted form builders provide embed code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<!-- Formbricks link survey embed -->
<script src="https://surveys.example.com/js/formbricks.js"></script>
<script>
  formbricks.init({
    environmentId: "your-env-id",
    apiHost: "https://surveys.example.com",
  });
</script>

<!-- Inline embed with iframe -->
<iframe
  src="https://forms.example.com/s/abc123"
  width="100%"
  height="600"
  frameborder="0"
  style="border: 1px solid #e2e8f0; border-radius: 8px;"
></iframe>

Choosing the Right Tool

The best self-hosted form builder depends on your specific use case:

Choose Formbricks if you need modern UX surveys with in-app widgets, A/B testing, and experience management features. It has the most polished interface and is actively developed with a growing community.

Choose NocoDB or Baserow if your form responses should live directly in an operational database. The tight integration between forms and data means zero sync overhead — every submission is instantly queryable.

Choose LimeSurvey if you need enterprise-grade survey capabilities: complex skip logic, quota management, multi-language support, and participant tokens. It is the most powerful option for academic and government research.

Choose OhMyForm if you need a lightweight, community-friendly survey tool with diverse question types and minimal infrastructure requirements.

Choose Fider if your goal is collecting and prioritizing user feedback rather than traditional form data. The voting and status-tracking features make it ideal for product teams.

Backup and Maintenance

Regardless of which tool you choose, implement a regular backup strategy:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#!/bin/bash
# backup-forms.sh - Backup all form builder databases
BACKUP_DIR="/backups/forms/$(date +%Y-%m-%d)"
mkdir -p "$BACKUP_DIR"

# PostgreSQL databases
for db in formbricks nocodb fider limesurvey; do
  docker exec postgres pg_dump -U "${db}" "${db}" | gzip > "${BACKUP_DIR}/${db}.sql.gz"
done

# Named volumes (plugins, themes, uploads)
docker run --rm -v formbricks_themes:/data -v "$BACKUP_DIR:/backup" \
  alpine tar czf /backup/formbricks_themes.tar.gz -C /data .

# Retain only last 30 days of backups
find /backups/forms -type d -mtime +30 -exec rm -rf {} +

echo "Backup completed: $BACKUP_DIR"

Schedule this with cron:

1

0 2 * * * /usr/local/bin/backup-forms.sh >> /var/log/form-backups.log 2>&1

Conclusion

The self-hosted form builder landscape in 2026 offers compelling alternatives to every major SaaS product. Whether you need the UX polish of Formbricks, the database-native simplicity of NocoDB, the enterprise depth of LimeSurvey, or the feedback-focused approach of Fider — there is a production-ready open-source tool that keeps your data under your control.

Deploy any of these with Docker Compose, front them with a reverse proxy and TLS, connect them to your existing tooling via webhooks or direct database access, and you will have a form collection pipeline that is faster, more private, and more flexible than any SaaS alternative.

Frequently Asked Questions (FAQ)

Which one should I choose in 2026?

The best choice depends on your specific requirements:

• For beginners: Start with the simplest option that covers your core use case
• For production: Choose the solution with the most active community and documentation
• For teams: Look for collaboration features and user management
• For privacy: Prefer fully open-source, self-hosted options with no telemetry

Refer to the comparison table above for detailed feature breakdowns.

Can I migrate between these tools?

Most tools support data import/export. Always:

1. Backup your current data
2. Test the migration on a staging environment
3. Check official migration guides in the documentation

Are there free versions available?

All tools in this guide offer free, open-source editions. Some also provide paid plans with additional features, priority support, or managed hosting.

How do I get started?

1. Review the comparison table to identify your requirements
2. Visit the official documentation (links provided above)
3. Start with a Docker Compose setup for easy testing
4. Join the community forums for troubleshooting