I have spent years building on Airtable, Make and Noloco, and I still like them. I have also moved a large, business-critical project from that stack onto Supabase, Vercel and Next.js, with Claude Code doing much of the typing. The fears people bring to that conversation are consistent: losing linked records, lookups and rollups; record-ID links breaking; staff losing the ability to fix data themselves; downtime; depending on one developer; and data loss. Every one is real, and every one is avoidable if you treat the migration as an operations project rather than a database export.

Phase 1: Audit first, and be willing to conclude "stay"

Kumohq puts it well: a migration "should begin with an operating inventory, not a database export." Before I touch a schema I want a complete list of what the business runs on: every base, every table with its record count, every Airtable automation, every Make scenario with its trigger and step count, every Noloco or Softr screen, and every integration that reads or writes the base.

Then I ask what actually hurts. The usual answers are grid views that take seconds to load, Make scenarios timing out when the Airtable API throttles (5 requests per second per base, then a 30-second lockout), every reviewer needing a full paid seat, or permissions that cannot give a client a clean slice of the data.

Some answers are not. Kreante's guidance is to stay if you have fewer than 20,000 records and low growth, if the main use is internal reporting, or if you are pre-product-market fit, because migration time delays validation. I agree with all three. If the audit shows a tidy base with modest volume and a team that happily edits its own schema, the right outcome is a cleanup, not a rebuild. An audit that cannot end in "stay" is a sales pitch.

Phase 2: Decide the destination shape

There are two honest shapes, and the audit tells you which one you need.

Full rebuild

Supabase (Postgres, auth, storage, edge functions) as the system of record, a Next.js application on Vercel for the admin and any external portal, and automations moved into the database or small services. Right when the portal is customer-facing, when performance or permissions are the pain, or when the Make layer breaks every week.

Hybrid

Supabase becomes the system of record, but Airtable (or Softr on top of it) stays as the editing surface, connected by a two-way sync tool such as Whalesync. Buyers ask for this directly: one Airtable community poster wanted a faster API so "our internal team can continue to work on client data through an airtable backend." It is a legitimate first step, and it calms the "we will lose our editing experience" fear immediately.

It has one limitation to design around. Formula, rollup and lookup fields sync one way only. As Whalesync documents, "Postgres won't recalculate those values; only Airtable will, and the new value then syncs back." So your business logic still lives in Airtable, and anything the new application needs to compute must be rebuilt in SQL anyway. I treat the hybrid as a bridge, not a destination; Softr users on Supabase have also reported connection pool exhaustion as traffic grows.

Phase 3: Redesign the schema

This is where the migration is won or lost, and it is the part a sync tool cannot do for you. The job is to translate what Airtable does implicitly into what Postgres does explicitly. This is the mapping I start from.

Airtable concept Postgres / Supabase equivalent Note
Table and field Table with typed columns Every field gets a real type, not text
Linked record (one to many) Foreign key with a constraint Decide which side owns the link
Linked record (many to many) Join table with two foreign keys Most "allow multiple" links end up here
Lookup Join in a view, or generated column Derive it; never copy the value
Rollup and count Aggregate in a view or materialized view CSV exports freeze these; recompute
Formula SQL expression, generated column or function Some are business rules in disguise
Single select Enum or small lookup table Lookup table if staff add options
Multiple select Join table, or array column for tags Table if options carry meaning
Attachment Supabase Storage bucket plus files table Copy the bytes; Airtable URLs expire
Record ID (rec...) UUID primary key plus legacy_id column Old links redirect; re-runs upsert
Collaborator permissions Supabase Auth plus row-level security Write the access model down first

The linked-record work is the part people dread. One Latenode poster summed it up: "Reality hit hard when I tried mapping the linked records to proper foreign keys." Airtable let you create relationships without deciding their direction or cardinality; Postgres makes you decide. The deciding happens once, on paper, with the people who own the data in the room. After that the database enforces it forever.

The legacy_id column deserves its own sentence. An Airtable community user described the fear precisely: when IDs change, "links we give the clients in emails" stop working. So I keep every original record ID, and the new application answers old-style URLs with a redirect. Nobody's bookmark breaks.

Phase 4: Move the data

Do not export CSVs and import them. A CSV flattens linked records into comma-separated names, turns rollups into frozen numbers, imports every column as text, and leaves attachments as URLs that expire within hours.

Properly means pulling records through the Airtable API (respecting the rate limit and the 100-record pages) or a sync tool, and writing them into the new schema with the legacy_id as the upsert key, so the job can run again and again without creating duplicates. I run the load on day one, then every day of the build, because the business keeps working in Airtable while I work on Supabase, and the two must not drift apart.

Then I validate in three layers. Record counts per table must match exactly. Relationship counts must match: if a client had 14 projects in Airtable, the foreign keys must give 14 in Postgres. And a sample of computed values, the rollups and formulas I rebuilt in SQL, must match what Airtable shows for the same record on the same day. Cotera reported two companies that each spent over three months migrating and both lost data. That is what happens when validation is a glance, not a script.

Phase 5: Rebuild the automations

Make scenarios and Airtable automations do not carry over. That sounds frightening until you group them by trigger type: there are only four kinds, and each has a natural home.

  • "When a record changes" flows become database triggers or Supabase database webhooks calling an edge function. They fire in milliseconds and never poll.
  • Scheduled flows (nightly reports, monthly invoices) become pg_cron jobs or a Vercel cron route, with no 40-minute execution cap of the kind Make staff describe for paid-plan scenarios.
  • Inbound webhook flows (payment events, form submissions) become Next.js API routes that validate the payload and write to the database.
  • Long-running or bulk flows become a small worker processing a queue table in batches, which is what people were hand-building inside Make with data stores anyway.

Whatever the home, every run is logged to a table: what fired, with what input, what it did, whether it failed. The missing audit trail is a quiet cost of glue tools, and it is cheap to fix once you own the code.

And keep Make for what it is good at. If a scenario posts a Slack message when a deal closes, point it at a Supabase webhook and move on. Retire the ones with iterators over thousands of records, several conditional branches, or per-case error handling, because those burn credits and time out.

Phase 6: Rebuild the interface

This phase decides whether your staff feel upgraded or demoted. Kumohq's warning is the right one: "Do not expose PostgreSQL directly to business users as a substitute for an access model." A bare database is not an operations tool, and the fear of needing a developer for every data fix is justified if that is what you ship.

So the internal admin gets built first, and it is built to feel like Airtable where that matters: a grid per table, filters and sorts, saved views, inline editing, bulk edit, and a record page with related records as linked lists. With Next.js and Claude Code I can generate a consistent admin for twenty tables in days, and because it is driven by the schema, adding a column later is a small change, not a project. Staff can still fix a typo in a client name on day one. That is non-negotiable.

The external portal is where you gain the most. The Noloco or Softr portal becomes a Next.js application with authentication through Supabase Auth and row-level security in the database. The client sees their projects and nothing else, not because a screen filter hides the rest but because the database refuses to return it. Viewer seats cost nothing and you own the code.

Phase 7: Parallel run and cutover

Never cut over on a flag day. Kreante's rule is to "never cut over without running both systems in parallel for at least one full business cycle," and the guides I trust put that period at two to six weeks. For a monthly invoicing business that means one full month-end runs in both systems and the outputs are compared line by line.

Cutover then happens domain by domain, following Kumohq's advice to "choose one low-coupling domain and move it first." Perhaps suppliers go first because nothing external depends on them, then clients and projects, then the customer portal last, after the team has lived on the new admin for weeks. Each domain has a written source of truth at every moment, and each step has a rollback: the sync is still running, so pointing an interface back at Airtable is a configuration change, not a recovery.

Keep paying for Airtable, Make and the portal builder until the last domain has moved and a full cycle has run cleanly. A few weeks of overlapping subscriptions is cheap; a rushed cutover is not.

The three things I will not compromise on

  • No cutover without a reconciled record count and relationship count, produced by a script I can run again tomorrow.
  • Every original Airtable record ID is preserved, and every old link redirects to the right page.
  • Staff can view, filter and edit their own data on day one, without asking a developer.

Phase 8: After go-live

The first month is when hidden assumptions surface, so I plan for it. Monitoring means alerts on failed automation runs, slow queries and portal auth errors. Backups mean Supabase point-in-time recovery plus a scheduled export you control, tested by restoring it once. Documentation means a short runbook: where each automation lives, how to add a column or a user, how to roll back a deployment.

Then you choose between a small retainer and a clean handover. Both are fine. A system only one person understands is not.

On AI-assisted development, I will be specific. Claude Code is excellent at the repetitive, well-specified parts: typed data access from the schema, twenty consistent admin screens, the validation scripts, converting a documented Make scenario into an edge function, and tests for all of it. It compresses weeks of typing into days. It is not a substitute for the audit, the schema decisions or the access model. Those come from knowing how the business runs, and if you let a tool make them you get a fast build of the wrong thing.

What a good outcome looks like

For a third-party reference point, Kreante published a case study of a logistics-adjacent platform with about 80,000 records across six linked tables, 12 Airtable Business seats and Make automations. Over an eight-week phased migration with a parallel run on live records, database cost fell from roughly $540 to $25 a month on Supabase Pro and average automation run time dropped from 4.2 seconds to 0.6 seconds. Their timeline guidance, four to eight weeks for a simple base and ten to fourteen for a complex one, matches my experience.

The outcome that matters is quieter: the ops lead still opens a grid every morning and edits what needs editing, the portal loads instantly, the automations have a log, old links work, and nothing was lost. That is what "without breaking your business" means, and it is achievable if you refuse to skip the audit, the schema, the validation script and the parallel run.