Ryz Labs/Rescue/Airtable to Postgres
Rescue

Airtable to Postgres: Migration Runbook for Apps That Outgrew a Base

How to move an app that uses Airtable as its backend onto PostgreSQL without a big-bang weekend: schema mapping, constraints, a dual run and a clean write cutover.

Migrating Airtable to Postgres means moving your app's system of record out of a base into a relational database with real constraints, while Airtable users keep working. The approach we recommend: keep the interfaces and workflows that already work, move the data and its rules into PostgreSQL behind your app, run both in parallel until the numbers reconcile, then cut over writes. Success depends on one thing: finding every rule your base enforces implicitly (formulas, rollups, automations, the way people use linked records) and making it explicit in the schema before you move a single row.

What Airtable gives you, and where the database job starts

Airtable is a superb place to model a business before anyone writes code, and many products start with an app reading and writing a base through the API. Each plan sets ceilings. Per the Airtable plans page, a base holds up to 1,000 records on Free, 50,000 on Team and 125,000 on Business, with attachment storage of 1 GB, 20 GB and 100 GB per base on those plans. A table can carry 500 fields and a base up to 1,000 tables. Programmatic access goes through the Web API, which per the rate-limit documentation allows 5 requests per second per base and 50 requests per second per user across personal access tokens. Change notifications come from the Webhooks API.

None of that is a problem while the base is a tool for a team. It becomes a database problem the day the base sits behind a customer-facing app: when customers trigger writes, finance reconciles revenue from a rollup, or a buyer asks who can read which rows. Then you need referential integrity, transactional writes, per-row authorization and predictable throughput. PostgreSQL gives you all of those, and the current major release is PostgreSQL 19 (19.0, released November 19, 2026), which the project's versioning policy supports for five years after release. Still choosing an engine? See our PostgreSQL vs MySQL guide and MongoDB vs PostgreSQL guide.

Where an Airtable-backed app breaks first

Ordered by severity once real traffic arrives.

1. The per-base request ceiling turns into user-facing latency

Five requests per second per base is shared by everything touching that base: app, scripts, sync jobs, integrations. When the limit is exceeded the API returns a 429, and clients must then wait 30 seconds.

Detect it: log a busy day of API calls by base and status, then count 429s and peak requests per second. Fix: short term, one write queue per base with backoff plus a read cache; long term, app traffic moves to Postgres, where throughput depends on your instance and indexes.

2. Monthly API caps and throttling on the plan

Plans also cap calls per workspace per month: 1,000 on Free and 100,000 on Team, with Business unlimited. Per Airtable's API call limits article, a Team workspace over its cap slows to 2 requests per second, and Free is blocked after a 30-day grace period.

Detect it: compare the workspace's monthly call count against the plan cap, attributed per token. Fix: replace polling with webhooks now; plan to stop routing customer traffic through the API at all.

3. Record and attachment ceilings arrive faster than forecast

Append-only tables (events, orders, messages) grow without limit against one per-base record ceiling. Splitting into a second base breaks linked records across the split and doubles every sync.

Detect it: record count per table over six months against the plan limit, plus attachment storage. Fix: move high-volume tables first; files go to object storage with only a key in the database.

4. Business logic hiding in formula, lookup and rollup fields

The most expensive surprise is how much of the product lives in field configuration. A rollup that sums invoice lines is your revenue definition. Rollups, by Airtable's own rollup field overview, require a linked record field and aggregate values across linked records, so every rollup is also a statement about your relationships. An export gives you computed values, not the rules behind them.

Detect it: list each computed field with its exact expression, inputs and dependents. Fix: each one becomes a generated column, a view or application code with a test that pins its current output on real records.

5. Linked records that the data layer doesn't police

A linked record field looks like a foreign key, but your app should treat it as a list of references that someone can edit by hand. Expect orphaned links, rows linked to two parents when the business assumes one, and links to a record someone duplicated instead of edited.

Detect it: script cardinality checks on an export: orders with zero or two customers, line items linked to archived products. Fix: in Postgres, a foreign key requires that values in a column match a row in another table, so the cleanup happens once, during the migration, and the database refuses the bad state afterward.

6. Multi-step writes with no atomic boundary

Creating an order, its line items and a stock decrement is several rate-limited API calls. If the third call fails, the first two have already happened. Retry and cleanup scripts are where duplicates come from.

Detect it: find every flow that writes to more than one table. Fix: in Postgres these flows become single transactions with idempotency keys, so a retried request either commits once or not at all.

7. Automations doing backend work under run quotas

Per Airtable's automations guide, runs per workspace per month are capped (100 on Free, 25,000 on Team, 100,000 on Business, 500,000 on Enterprise Scale), each trigger counts as a run, and failed attempts count too. The script action has a timeout (temporarily 120 seconds, normally 30), a limit of 50 fetches and 15 mutations per second.

Detect it: list automations per base with monthly runs; flag anything touching money or customers. Fix: money and provisioning flows move to a worker or queue backed by Postgres; internal notifications can stay as automations.

8. Authorization and sync that stop at the base boundary

If the app reads Airtable with one service token, every user's request runs with the same access, and "customer A can only see customer A's rows" lives entirely in your application code. Sync has its own ceilings: per the sync documentation, Team allows 10 sources per table and 10 synced tables per base (20 on Business and Enterprise), and integrated sync caps at 10,000 records per source.

Detect it: grep every query path for the tenant filter and write one test per endpoint that requests another tenant's record. Fix: in Postgres, tenant isolation moves into the database with row-level security, covered below.

Migration readiness checklist

The migration plan, step by step

Phase 0: Freeze the schema and snapshot the base

Agree a schema freeze, then take a complete snapshot. Per the views documentation, CSV export works per grid view on web and desktop, leaves out comments and field descriptions, and attachment URLs from the export expire after a few hours. So the snapshot is an API script (respecting the per-base limit) that saves every table and attachment to storage you own, plus a captured record of field descriptions and formulas. Exit criteria: you can rebuild every table's contents from your snapshot without touching Airtable.

Phase 1: Design the schema from the base

Each table gets a surrogate primary key and keeps the original record ID for lineage. A one-to-many linked record becomes a foreign key column on the child; a many-to-many becomes a join table with a composite key. Single selects become enums when the values are stable and owned by engineering, or a lookup table with a foreign key when operations needs to add values. Formulas that depend only on the same row become generated columns; PostgreSQL has stored and virtual kinds, and in PostgreSQL 19 a generated column is virtual by default, so declare STORED when you need to index the value or read it often. Rollups and cross-table lookups become views. Exit criteria: every field in the inventory maps to a column, a view or code, and every relationship's cardinality is signed off.

Phase 2: Constraints and row-level security

Add NOT NULL where the business means required, foreign keys on every relationship, and CHECK constraints for the rules that lived in formulas and people's habits: amounts non-negative, end date after start date, status transitions limited to known values. Write cleanup queries that bring the snapshot into compliance, and log every record they change. If the app serves several customers, add a tenant_id to every tenant-owned table, enable row-level security, and write policies with CREATE POLICY; the docs are explicit that row-level security must be enabled on the table for policies to apply. Exit criteria: the cleaned snapshot loads with every constraint on, and an automated test shows one tenant cannot read or write another tenant's rows.

Phase 3: Bulk load with COPY

Load with COPY, which reads CSV directly into a table. Load into loosely typed staging tables, transform with SQL, load parents before children, and build secondary indexes after the load. Script the run so it repeats from an empty database in one command. Exit criteria: a full load from snapshot completes unattended and the reconciliation queries match the snapshot exactly.

Phase 4: Dual run with Airtable still live

Airtable keeps working as the source of truth while Postgres follows it. One sync option is the Webhooks API sends a ping when data changes, the ping carries no data so your worker fetches the payloads, delivery is at-least-once so the upsert must be idempotent on the record ID, and webhooks created with a personal access token or OAuth expire after seven days unless refreshed. The simpler option is a scheduled job pulling records modified since the last run. Point read-only features (reports, search) at Postgres first. Run reconciliation on a schedule: counts per table, sums of money fields, counts per status and per tenant. Exit criteria: reconciliation is clean for an agreed run of consecutive checks, with every difference explained.

Phase 5: Cut over writes

In a low-traffic window, pause app writes to Airtable, drain the sync, reconcile once more, then switch the write path to Postgres. If operations still wants Airtable as a working surface, reverse the sync direction so the base becomes a read view fed from Postgres,. Exit criteria: all app writes land in Postgres, the reverse sync (if any) is monitored, and the rollback trigger has been retired by the named decision maker.

PhaseGoalKey techniqueExit criteria
0 Freeze and snapshotOwn a full copyAPI export script plus attachment downloadRebuild possible without Airtable
1 Schema designMake implicit rules explicitLinks to FKs, selects to enums or lookups, formulas to generated columns, rollups to viewsEvery field mapped and reviewed
2 Constraints and RLSDatabase refuses bad statesFK, CHECK, NOT NULL, CREATE POLICYClean load with constraints on; cross-tenant test fails closed
3 Bulk loadRepeatable migrationCOPY into staging, SQL transform, indexes lastUnattended load, exact reconciliation
4 Dual runProve parity under live useWebhook or scheduled sync, idempotent upserts, reconciliation countsAgreed run of clean checks
5 Write cutoverPostgres is the system of recordWrite pause, final drain, switch, optional reverse syncRollback window closed

Where to host Postgres

Any managed PostgreSQL works. Supabase is one option if you want an API layer and auth alongside it; two details matter here. Per Supabase's API security guide, tables created through the Dashboard have RLS enabled by default, but tables created in the SQL Editor need it enabled explicitly, and a migration script creates tables in SQL. And per its RLS guide, views bypass RLS by default, which matters because your rollups just became views. The same guide recommends an index on every column your policies filter on.

What an AI pod on your team does in the first two weeks

Week one

Week two

Our AI pod uses coding assistants for the repetitive parts: generating the field-to-column mapping draft, writing first-pass policies, producing test fixtures from the snapshot and triaging sync logs. Every change still goes through human review and the test suite before it merges.

Keep, harden or rebuild?

SituationRecommendation
Internal tool, a few dozen users, well under record and API capsKeep Airtable; add webhooks instead of polling and a nightly snapshot
Customer-facing app hitting 429s, but one base and simple logicExtract a backend: move app reads and writes to Postgres, keep Airtable as the ops surface via sync
Several bases, money flows in automations, multi-tenant customersFull migration with constraints, RLS and a dual run, as above
The app around the base is also no-code and is the bottleneckMigrate data and rebuild the app layer together; see the Bubble runbook

When not to bring in a team: you are still changing the data model every week while searching for product-market fit, the base serves a handful of internal users, or the only real pain is one polling integration you can swap for a webhook in an afternoon. Airtable is the right tool for those stages, and migrating early freezes a model you have not finished learning.

Typical team shape

A typical shape is a tech lead who owns the schema and cutover plan, one or two data engineers for the snapshot, transforms, COPY pipeline and reconciliation, a backend engineer (often one of our Python developers) to move the app's data layer and workers, and part-time QA automation if the money paths are complex. Many teams begin with a pod of 3 to 5 senior engineers (a tech lead plus engineers), and a full pod is about seven. Our data engineering teams run the pipeline side.

Ryz engineers on your team start from $7,000 per month (our published range is $7,000–$15,000 per engineer per month, mostly mid-level to senior), quoted per team. Project cost is team size × months × monthly rate. Once you say go, engineers can typically start in under two weeks. Ryz engineers work on your team, reporting to your leads. Scope your team with us.

Related

FAQ

Can Airtable handle production traffic as an app backend?

For internal tools and modest traffic, yes. For customer-facing apps, every caller shares a fixed request rate per base, plans cap monthly API calls, and bases cap records and storage, so real write traffic shows up as queued requests and throttling. The usual answer is to keep Airtable for the operations team and move the app's reads and writes to Postgres.

Do we have to rewrite the app to move from Airtable to Postgres?

Usually not. The front end and most business code stay; the data access layer swaps API calls for SQL, and some automations move to workers. The real work is the schema and the constraints the old data has to pass.

How long does an Airtable to Postgres migration take?

It depends on the number of bases and tables, how much logic lives in computed fields and automations, how dirty the linked data is, whether the app is multi-tenant, and how long you want the dual run to last before you trust the numbers. We scope it after the inventory, because that is where the surprises are.

What does an Airtable migration cost?

Cost is team size times months times the monthly rate per engineer. The rate depends on seniority, and every quote is scoped per team, with the names of the people and a plan before work starts.

Will we lose the ability to keep using Airtable?

No, unless you want to. Many teams keep Airtable as the operations surface after cutover, fed by a sync from Postgres. The difference is that Postgres becomes the system of record, so the rules live in constraints and policies rather than field settings someone can change by accident.

Questions we didn't answer? Email info@ryzlabs.com.

Thanks — your message has been sent. We’ll get back to you soon.

Something went wrong while sending your message. Please try again or email info@ryzlabs.com.

Explore Ryz Labs

Software development servicesAI development companyIndustriesStaff augmentationAI pod teamsNearshore software developmentHire engineers by roleEngineer ratesGuidesBuyer guidesCase studiesHow we vet engineers

Ryz Labs

Senior engineers on your team. AI pod teams that ship.

Tell us what you're building. You get a scoped plan, a price and the names of the people who would do the work.

  • Only the top 1% of tens of thousands interviewed make it
  • On US business hours, including New York hours
  • Trusted by Fortune 500 engineering teams

Tell us who you need

A Ryz partner replies with a scoped team plan.

Start a conversation →

Prefer to talk? Book a 15-min call →