How to Self-Host Teable — Airtable Alternative 2026

TL;DR

Teable is a next-generation open source Airtable alternative built on PostgreSQL — unlike Airtable's proprietary database, Teable stores your data in standard SQL tables you can query directly. It supports real-time collaborative editing, 20+ field types, multiple views (grid, gallery, form, calendar, Gantt), automations, REST API, and an impressive performance profile that handles millions of rows without the pagination walls Airtable imposes. Self-hosting requires Docker Compose and a VPS with 2GB RAM. Airtable charges $20/user/month for features Teable provides free.

Key Takeaways

• Teable: 15K+ GitHub stars, TypeScript/NestJS backend, built on PostgreSQL — data is in real SQL tables
• Performance: handles 1M+ rows in a single table smoothly; Airtable limits free tier to 1,200 rows and caps paid tiers at 100K-500K rows
• Views: Grid, Gallery, Form, Calendar, Kanban — all with real-time sync
• API: REST API auto-generated per table, compatible with most Airtable API clients
• Automations: trigger-action workflows (record created/updated → send webhook, create record, etc.)
• Alternatives: NocoDB (more mature, 50K+ stars), Baserow (also open source, more polished UI), Grist (spreadsheet-focused)

---

Why Teable Over NocoDB or Baserow?

The open source Airtable space is crowded — NocoDB, Baserow, and Grist all exist. Teable's differentiators:

1. Native PostgreSQL: data lives in real PostgreSQL tables with standard column types. You can JOIN your Teable data with your app database, run analytics with any BI tool, or access it via psql directly.
2. Performance: built for large datasets from the ground up. NocoDB and Baserow struggle beyond 100K rows; Teable handles millions.
3. Modern UI: closest in feel to Airtable's UX — smooth, fast, drag-and-drop column ordering, inline editing
4. Newer: less battle-tested than NocoDB (launched 2023 vs NocoDB 2018), but actively developed with frequent releases

Choose NocoDB if you need maximum maturity and a larger community. Choose Teable if performance and data portability are priorities.

---

Prerequisites

• Docker + Docker Compose
• 2GB RAM minimum (4GB recommended for comfortable use)
• Domain with SSL for production (Teable's real-time features require HTTPS)
• VPS: Hetzner CX22 (€4.15/mo) works for personal/team use

---

Docker Compose Setup

Create /opt/teable/docker-compose.yml:

version: '3.8'

services:
  teable-db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: teable
      POSTGRES_USER: teable
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - ./postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U teable -d teable"]
      interval: 10s
      timeout: 5s
      retries: 5

  teable-db-migrate:
    image: ghcr.io/teableio/teable:latest
    depends_on:
      teable-db:
        condition: service_healthy
    environment:
      PRISMA_DATABASE_URL: postgresql://teable:${POSTGRES_PASSWORD}@teable-db:5432/teable
    command: sh -c "node ./dist/prisma/migrate-prod.js"
    restart: on-failure

  teable:
    image: ghcr.io/teableio/teable:latest
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"
    depends_on:
      teable-db-migrate:
        condition: service_completed_successfully
    environment:
      # App
      PUBLIC_ORIGIN: https://teable.example.com
      BACKEND_JWT_SECRET: ${JWT_SECRET}
      BACKEND_SESSION_SECRET: ${SESSION_SECRET}
      # Database
      PRISMA_DATABASE_URL: postgresql://teable:${POSTGRES_PASSWORD}@teable-db:5432/teable
      # Email
      BACKEND_MAIL_HOST: smtp.resend.com
      BACKEND_MAIL_PORT: 587
      BACKEND_MAIL_USER: resend
      BACKEND_MAIL_PASS: ${SMTP_PASSWORD}
      BACKEND_MAIL_FROM: teable@example.com
      # Storage (local or S3)
      BACKEND_STORAGE_PROVIDER: local
      # For S3:
      # BACKEND_STORAGE_PROVIDER: s3
      # BACKEND_STORAGE_S3_REGION: us-east-1
      # BACKEND_STORAGE_S3_BUCKET: teable-files
      # BACKEND_STORAGE_S3_ACCESS_KEY: ${S3_KEY}
      # BACKEND_STORAGE_S3_SECRET_KEY: ${S3_SECRET}
    volumes:
      - ./uploads:/app/.teable

volumes:
  postgres:

Create .env:

POSTGRES_PASSWORD=strong-postgres-password

# Generate: node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
JWT_SECRET=your-jwt-secret
SESSION_SECRET=your-session-secret

SMTP_PASSWORD=your-smtp-key

docker compose up -d
# Migrations run automatically via teable-db-migrate service
# Access at http://localhost:3000

---

First Login and Setup

On first access, register the first user — this account automatically gets admin privileges. Navigate to:

1. Create a Space — equivalent to an Airtable workspace
2. Create a Base — a collection of related tables (equivalent to Airtable base)
3. Add a Table — name it, add fields

Available Field Types

Teable supports 20+ field types matching Airtable's:

Category	Fields
Basic	Single line text, Long text, Number, Checkbox, Date
Link	Link to another record, Lookup, Rollup
Select	Single select, Multiple select
Media	Attachment
User	User, Created by, Last modified by
Auto	Auto number, Created time, Last modified time, Formula
Reference	Link (relates tables), Count

---

REST API

Every Teable table gets an auto-generated REST API:

// Get records with filtering and sorting
const response = await fetch(
  'https://teable.example.com/api/table/tblXXXXXXX/record?' + new URLSearchParams({
    'filter': JSON.stringify({
      'conjunction': 'and',
      'filterSet': [
        { 'fieldId': 'fldStatus', 'operator': 'is', 'value': 'Active' },
        { 'fieldId': 'fldCreatedTime', 'operator': 'isAfter', 'value': '2026-01-01' },
      ],
    }),
    'orderBy': JSON.stringify([{ 'fieldId': 'fldCreatedTime', 'order': 'desc' }]),
    'take': '20',
    'skip': '0',
  }),
  {
    headers: {
      Authorization: `Bearer ${process.env.TEABLE_API_TOKEN}`,
    },
  }
)

const { records, total } = await response.json()

// Create a record
await fetch('https://teable.example.com/api/table/tblXXXXXXX/record', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.TEABLE_API_TOKEN}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    records: [{
      fields: {
        Name: 'New Customer',
        Email: 'customer@example.com',
        Status: 'Active',
        'Signup Date': new Date().toISOString(),
      },
    }],
  }),
})

Get your API token from Account Settings → API Token. Table IDs (tbl...) and field IDs (fld...) are visible in the URL when viewing a table.

---

Views and Collaboration

Every Teable table supports multiple views — each with its own filters, sorts, hidden fields, and grouping. Views are non-destructive overlays on the same data:

Available views:

• Grid: Spreadsheet-style, column resize, row height, frozen columns
• Gallery: Card-based layout, ideal for photo/image collections
• Form: Public intake form, submit records from outside users without Teable accounts
• Calendar: Date-field-based calendar layout with drag-and-drop scheduling
• Kanban: Card-based status board (requires a single-select field as the grouping column)

Sharing and embedding: Each view can be shared via a public URL (read-only or with form submission). Embed a form view on your website:

<!-- Embed a Teable form -->
<iframe
  src="https://teable.example.com/share/shrlinkid/view?theme=light"
  width="100%"
  height="600"
  frameborder="0"
  title="Contact Form"
></iframe>

Shared views support password protection and can be restricted to specific IP ranges for internal use. Toggle sharing in the view menu → Share View.

Real-time collaboration: Multiple team members can edit the same table simultaneously. Changes appear in real time without page refresh — cursor positions and active cell highlights show who's editing what, similar to Google Sheets. This is powered by Teable's SSE (Server-Sent Events) connection, which requires the proxy_read_timeout 3600 in the Nginx config.

---

Migrating from Airtable

Teable provides a CSV import that handles Airtable exports:

1. In Airtable: Base → Download CSV (exports current view data)
2. In Teable: Table → Import → CSV
3. Map Airtable column types to Teable field types
4. Import — Teable handles up to 100K rows per import batch

For larger migrations or automated sync:

// Airtable to Teable migration script
import Airtable from 'airtable'

const airtable = new Airtable({ apiKey: process.env.AIRTABLE_TOKEN })
const base = airtable.base('appYourBaseId')

// Fetch all records from Airtable
const records = await base('Contacts').select({ view: 'Grid view' }).all()

// Batch insert into Teable API
const BATCH_SIZE = 100
for (let i = 0; i < records.length; i += BATCH_SIZE) {
  const batch = records.slice(i, i + BATCH_SIZE)
  await fetch('https://teable.example.com/api/table/tblXXXXXXX/record', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.TEABLE_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      records: batch.map(record => ({
        fields: {
          Name: record.get('Name'),
          Email: record.get('Email'),
          Status: record.get('Status'),
        },
      })),
    }),
  })
  console.log(`Migrated ${Math.min(i + BATCH_SIZE, records.length)}/${records.length}`)
}

---

Troubleshooting Common Issues

Real-time sync not working:

• Verify Nginx has proxy_read_timeout 3600 set — without this, SSE connections time out after 60 seconds
• Check that PUBLIC_ORIGIN in .env matches your actual domain exactly (including https://)
• Test the SSE endpoint: curl -N https://teable.example.com/api/sse

Migration service fails on startup:

docker compose logs teable-db-migrate
# If postgres isn't ready: increase the healthcheck interval
# If schema conflicts: check if a prior migration left partial state
docker compose exec teable-db psql -U teable -d teable -c "\dt _prisma_migrations"

File uploads failing: Ensure the uploads volume is writable:

docker compose exec teable ls -la /app/.teable
# If permission denied:
docker compose exec teable chown -R node:node /app/.teable

Large table performance: For tables with 500K+ rows, add PostgreSQL indexes on commonly filtered fields. Teable table IDs are in the format tblXXXXXXX — find the exact table name with \dt tbl* in psql, then:

-- Add index for a status field
CREATE INDEX idx_teable_status ON "tblAbc123"("fldStatus");
-- Analyze to update query planner
ANALYZE "tblAbc123";

---

Direct Database Access

Since Teable uses PostgreSQL, you can query your data directly — a huge advantage over Airtable:

# Connect to Teable's database
docker compose exec teable-db psql -U teable -d teable

# Find your table (Teable creates tables named by their ID)
\dt tbl*
# Lists: tblAbc123, tblXyz789, etc.

# Query directly
SELECT * FROM "tblAbc123" WHERE "fldStatus" = 'Active' LIMIT 10;

# JOIN with your application database
-- (if connected to the same PostgreSQL instance)
SELECT t.*, u.plan_tier
FROM "tblAbc123" t
JOIN app.users u ON t."fldUserId" = u.id::text
WHERE u.plan_tier = 'enterprise';

This direct SQL access unlocks use cases Airtable can't support: complex analytics, BI tool integration (Metabase, Superset), data pipelines, and automated data maintenance.

---

Automations

Teable's automation builder (Settings → Automations within a base) supports trigger-action workflows:

Triggers:

• Record created
• Record updated (any field or specific field)
• Record deleted
• Form submitted
• Scheduled (hourly, daily, weekly)

Actions:

• Send webhook (HTTP POST to any URL)
• Send email notification
• Create a record
• Update a record
• Find records

Example: Slack notification for new form submissions:

1. Trigger: Record created in Contact Submissions table
2. Action: Send webhook to Slack webhook URL
3. Body: {"text": "New submission from {{Name}}: {{Email}}"}

---

Nginx Configuration

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

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

  client_max_body_size 100m;

  location / {
    proxy_pass http://127.0.0.1:3000;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection 'upgrade';
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_read_timeout 3600;  # long timeout for real-time connections
  }
}

The proxy_read_timeout 3600 is important — Teable uses long-polling/SSE for real-time updates.

---

Backup and Upgrading

# Backup
DATE=$(date +%Y%m%d)
docker compose exec -T teable-db pg_dump -U teable teable | gzip > "/opt/backups/teable-$DATE.sql.gz"

# Upgrade
docker compose pull teable
docker compose up -d --force-recreate teable-db-migrate  # run migrations first
docker compose up -d --force-recreate teable
docker compose logs teable | grep -i "started\|error"

---

Cost vs Airtable

Plan	Airtable	Teable Self-Hosted
1-5 users	$0 (1,200 rows limit)	Free (unlimited)
Team (5 users)	$100/month	~€5/month VPS
Business (25 users)	$500/month	~€10/month VPS
Row limit	100K-500K rows	Unlimited (PostgreSQL)
API calls/month	100K (paid)	Unlimited

---

Methodology

• Teable documentation: help.teable.io
• GitHub: github.com/teableio/teable (15K+ stars)
• Tested with Teable latest, PostgreSQL 16, Docker Compose v2

---

Browse open source alternatives to Airtable on OSSAlt.

Related: How to Self-Host Baserow — Open Source Airtable Alternative 2026 · NocoDB vs Baserow vs Grist: Open Source Airtable Alternatives 2026