Building for the Long Term: Why We Replaced Airtable with NocoDB (Real Case Study)
Our client's table hit 710 columns, 210 over Airtable's limit, mid-project. Why we moved to NocoDB instead of patching, and what it taught us.
- Business
- Case Study

In short
- In a live client project the main table grew to 710 columns, while Airtable allows 500 per table. We were 210 columns over.
- Splitting the table and joining it back with lookups was possible, but it multiplies fragility, hidden complexity, automations and debugging time.
- We chose to change platform mid-project and covered all additional costs ourselves: NocoDB on PostgreSQL, rebuilt from scratch, migrated in validated batches, with no downtime.
- The lesson is not that Airtable is bad. A tool that works well can still be the wrong foundation once the system becomes the operational backbone.
- A successful migration is not the end of a project. It is the beginning of responsibility.
At 710 columns, we hit a wall we didn't see coming. Airtable allows 500 fields per table. We were 210 over, in the middle of a live client project.
Nobody had made a mistake. The system was doing exactly what it should: growing with the business. This is what happened next, and why we changed platforms halfway through.
A successful migration, then a wall nobody planned for
In two earlier articles I described this real client project: a complex operational system moved from Excel to Airtable. You can read how the migration from Excel to Airtable went and how Google Sheets and Airtable compared in a real CRM case. This article continues the same project, and, as promised, I will not hide the mistakes or the uncomfortable decisions.
The workflows were faster. The data finally had structure. The team was getting ready for training. From the outside it looked like a textbook success.
But the client did not wait for us to finish. They did what an engaged owner does: created new views for how the team really works, added fields for operational details, widened the data model as new cases appeared. That was not misuse and not scope creep. It was real adoption, and every new need added a column.
At some point we reviewed the main table and paused. It had grown beyond 700 columns. Each column was a real business question, something the team needed to track to do the job better.
The hard limit: 500 columns, and we had 710
Airtable allows a maximum of 500 fields per table. We had over 710. That limit does not show up in demos and is rarely mentioned in tutorials. Once you hit it, it was no longer a future risk. It was a blocker that forced a decision.
The obvious fix was to split the table: create a second one, move some columns there, link the two and rebuild the full view with lookup fields. Technically supported. Architecturally worrying.
We rejected it, because joining one operational table to another through lookups brings four problems:
| Risk | What it means in practice |
|---|---|
| Fragility | You now depend on relationships staying correct, automations syncing and lookups not breaking. If one piece fails, the whole system becomes unreliable. |
| Hidden complexity | To users it still looks like one system. Behind the scenes it is several tables stitched together with logic, so every later change is harder. |
| Automation explosion | Every sync between tables is an automation, and every automation can fail. You do not reduce complexity, you move it where it is harder to see. |
| Debugging nightmare | The question changes from "which field is wrong?" to "which table, which lookup, which automation, which sync failed?" Troubleshooting time multiplies. |
Why we changed platform mid-project, and who paid for it
The question stopped being "can we make this work in Airtable?" It became "should we force Airtable to be something it was never designed to be?"
What the client needed now was no longer a flexible spreadsheet tool. They needed an operational database, long-term structural stability and freedom to evolve without hidden ceilings. The system had outgrown its foundation.
Changing tools in the middle of a project means more work, more risk, more responsibility. So we made a commitment to the client: all additional costs from that point would be covered by us. We had promised a sustainable system, and a fragile workaround would have broken that promise.
Airtable is an excellent product, and for many cases it is the right choice. This project simply crossed a line: it was no longer a tracking tool, it had become an operational backbone.
The rule we set before touching anything
The most dangerous phase was not the technical work. It was the transition. The system was already shaping how the business ran day to day: people were preparing to use it, processes were adjusting around it, trust was forming.
So before moving a single record we set one non-negotiable rule: the client's business must keep operating normally during the move. No downtime, no "we'll fix it later", no half-working states.
We also re-evaluated the platform, not just the setup. The problem was no longer views, formulas, automations or design. It was structural capacity. We needed a system that could:
- handle a very large number of fields in one table,
- evolve without artificial ceilings,
- stay understandable for non-technical users,
- and not need constant workarounds just to stay functional.
Airtable or NocoDB: when each makes sense
We chose NocoDB (an open-source tool that puts a spreadsheet-like interface on top of a real database). Not because it is "better" in general, and not because Airtable failed, but because the nature of the system had changed. What began as a simple database had become an operational database, and it needed a foundation designed for that role.
| Airtable | NocoDB on PostgreSQL | |
|---|---|---|
| Best when | Setup speed matters more than long-term scale; the number of fields per table is predictable; the data model is fairly stable | The system is the operational backbone and must keep growing |
| Columns per table | 500 | Set by the database underneath: PostgreSQL allows up to 1,600 columns per table |
| Structure and interface | Tightly coupled, they grow together without clear boundaries | Data layer separated from the interface layer |
| Cost and control | Per-seat plans | Open-source, self-hosted, full control over company data, unlimited team members, no per-seat pricing, noticeably cheaper monthly than Airtable's plans |
For this project those practical points mattered more than any feature list. Airtable began to struggle when the central table grew past hundreds of columns, when operational logic depended on one ever-growing dataset, and when every workaround made things more fragile instead of more resilient. None of these are mistakes. They are signs that a system has outgrown the tool's comfort zone.
It is also not an argument against Airtable. It is an argument for architectural honesty: every tool has a range where it shines and a point where pushing it further creates hidden debt.
How we migrated again, step by step
Step 1: Rebuild the database the right way
In Airtable, structure and interface are tightly coupled. In NocoDB with PostgreSQL they are not, and that gave us the chance to design the database on purpose instead of letting it evolve by accident.
- The schema was designed first, not discovered over time
- Field types were chosen deliberately, not "because they worked before"
- Naming conventions were standardised
- Redundant and overlapping fields were reviewed, not blindly copied
We did not simplify the business to make the database easier. The business was complex, and rightly so. Our job was to give that complexity a foundation that holds long term.
NocoDB can import an Airtable base directly. We tried it. But the imported structure only mirrored Airtable's constraints, not the system's real logic. So we rebuilt from scratch, field by field, checking every column against the original Excel logic and adding a field only when it had a clear purpose. It was not faster, but it was safer.
Step 2: Keep the views, because the team lives in them
Views were never the problem. They were one of the reasons Airtable worked so well early on. The client's team needs different perspectives for different roles, filtered views for daily work, and one dataset serving several operational needs. In NocoDB we kept:
- multiple views over the same table,
- role-specific visibility without duplicating data,
- stable filters and sorting people can trust every day.
For users, workflows stayed familiar, habits did not change and nothing broke. That was exactly the goal.
Step 3: Move the data without surprises
We did not do one massive import. That looks efficient and hides problems until it is too late. We migrated in batches and validated each one for record counts, field integrity and formatting edge cases. Every mismatch was investigated, and nothing was ignored "because it mostly works". It slowed us slightly and saved us from structural mistakes that would have been very expensive later.
Once the system lived on PostgreSQL, the conversation changed. Instead of "can the tool do this?" we asked "what should this system become next?" Analytics, internal tooling, AI-assisted workflows and custom interfaces are now possible without another rebuild.
What this project changed in how we build
The most dangerous systems are not the ones that break early. They are the ones that work just well enough to trap you. Airtable did not fail this project. It did exactly what it was designed to do. The mistake would have been pretending the project had not outgrown it.
The hardest decisions in system design are rarely technical. They are timing decisions: when to stop pushing a tool beyond its limits, when to admit that "working" is not the same as "safe", when to change direction before it becomes painful.
This is how our HARDEN method held up on this project:
| Step | What it meant here |
|---|---|
| Discover | We mapped the processes, then watched how the system evolved once people used it daily. |
| Design | We stopped designing for what the tool allowed and designed for what the business required. |
| Build | The system was rebuilt with guardrails, not shortcuts. |
| Break (QA) | We treated growth itself as a stress test, not as an exception. |
| Harden | Monitoring, validation and structural safety became non-negotiable. |
| Launch | The transition happened without breaking trust or daily operations. |
| Monitor | The system is now built to be observed, not just used. |
What to check in your own system this week
Tools will not protect you from complexity. Only architecture will, and architecture is about decisions, not software.
A successful migration is not the end of a project. It is the beginning of responsibility. I write these articles so that others do not have to learn this the hard way. If you want to know where your current tool will stop you, start with a Process X-ray and we will go through one process with you step by step.
Questions and answers
What is Airtable's column limit?
Airtable allows a maximum of 500 columns per table. In our client project the main table reached 710, so the limit became a hard blocker, not a future risk.
Why not just split the table into two?
It is technically possible, but every sync between tables becomes an automation and every automation a possible failure point. Complexity is not removed, only hidden, and debugging gets much slower.
Why did you choose NocoDB?
It keeps its columns in a database you control, and PostgreSQL allows up to 1,600 columns per table, so 710 was not a problem. It is open-source and self-hosted, gives full control over company data and has no per-seat pricing.
Does this mean Airtable is a bad tool?
No. Airtable is an excellent product when setup speed matters, the number of fields per table is predictable and the data model is fairly stable. This project simply outgrew it.