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.
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.
Ordered by severity once real traffic arrives.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.