What shipped.
Newest first. The gaps we still mean to close are on the wishlist.
September 2026
An API key can be read-only, or reach only the databases it needs
Read only refuses every write, whatever your own role is — the setting for a dashboard, a nightly export, or an agent you would rather could not delete a record. With more than one database, a key can be pointed at just the ones an integration needs; anything else answers as though it were not there. Both settings sit under the name box already answered with All databases and Read and write, so creating a key is still type a name, press Create — and both can be changed later on the line under the key’s name without touching the secret, so nothing needs re-pasting. Two acts stay a person’s job whatever the key: deleting a database and making someone an owner, since revoking a key can’t undo either.
Filter a date by what it isn’t
A date filter could say is, before, after, on or before, on or after — every way of naming a day except leaving one out. Now it can say is not: every booking that isn’t checking out today, every invoice not dated the 12th, in one condition. A record with nothing in that field counts as not being on that day, so is and is not between them account for the whole table. And it means the same thing wherever the question is asked — in a view’s filter, in a colour rule, in a webhook trigger, over the API.
A bookings starter, for anyone letting a place out
The first-run picker has a seventh starter: Bookings, two tables with the fields already laid out — the guest, the property they are in, a check-in date and a check-out date, party size, the total, where the booking came from, and whether it is paid. The two dates are the point. Add a calendar view, set Start to Check-in and End to Check-out, and every stay draws as a bar from the day they arrive to the day they leave, so a week is a shape rather than a column of dates you read one at a time. It links to a Properties table shaped exactly like the one in Short-stay turnovers, so the two starters fit together for anyone running both.
A formula can read a linked-record field
A formula could not look at a link at all, so the most ordinary label there is — which platforms is this episode on, who is this booking for — needed a lookup field first, sitting in the table doing nothing but being read by the formula beside it. Now a link comes into a formula as the names of the records it points at, joined the same way the cell shows them: IF({YouTube}, “on YouTube”, “”) works, and so does “on ” & {YouTube}. It costs what reading another table always costs here — the formula is worked out fresh on every read rather than stored, so it can be shown anywhere but not searched, filtered or sorted on — and the editor says so before you save. A link into a table whose records have no name is refused by name rather than quietly showing nothing.
A formula can ask about attachments
A formula could not look at an attachment field at all, which made the most ordinary question about one — does this record have a photo yet? — unanswerable without a checkbox somebody remembered to tick. Now it can: IF({Photos}, “has one”, “none”) works, and ARRAYLENGTH({Photos}) counts the files. That is the whole of it, deliberately. A formula is a real database column and can only see its own row, and file names live elsewhere, so anything beyond “is there one” and “how many” is refused by name rather than quietly writing something useless into the cell. ARRAYLENGTH counts a multi-select’s choices too, which nothing in the language could do before.
A formula can be shown as select chips
A formula that works out to a label — long stay, short stay, one night — used to read as plain grey text next to the real select field it was standing in for. It can now be drawn as coloured chips, exactly like a single select, and the values are already in the list when you switch it on: Tabla reads them out of your own formula rather than asking you to type them in and match them exactly. You pick the colours and drag the order, and that order is the order the field sorts and groups in — which is the point, because Small, Medium, Large sorted alphabetically reads Large, Medium, Small. Filtering offers the list instead of a box to spell into. A value the list doesn’t name still shows, in grey, and sorts last — nothing computed disappears because nobody picked a colour for it. And it changes nothing about the value: the column, the stored text and what the API returns are identical, so colouring or reordering the list touches no records and is instant on a table of any size. Number formulas got the same treatment — currency with your own symbol, percent, or a duration in h:mm — beside the decimal places they already had.
A field on its own is a question: is it filled in?
IF({Video Link}, “here”, “not yet”) now does what it looks like it does. A condition used to have to be a comparison, so asking the commonest question there is — does this cell have anything in it — meant writing {Video Link} != “” and knowing which of empty, blank or nothing the field stores underneath. A field standing on its own in a condition now asks whether it is filled in, whatever kind of field it is: text, a date, a number, a multi-select. A number counts zero as empty alongside blank, so IF({Discount}, …) reads as there is a discount; where you need to tell those two apart, = 0 and = BLANK() still do. A checkbox keeps the meaning it always had — ticked.
Formula text can span lines, and the box helps you write it
Text a formula builds can now break across lines: \n inside quotes starts a new one, \t makes a tab. CONCATENATE({Street}, "\n", {City}) writes an address the way an address is written, which matters the moment a formula feeds an invoice, a label or a message rather than a column of one-liners. The expression box grew up to match. It keeps your indentation when you press Enter and adds a level after an opening bracket, Tab and Shift+Tab move a line or a whole selected block in and out, and brackets and quotes close themselves — typing the closing half yourself steps over it instead of doubling it up. A long formula written in named steps now looks like the structure it has, rather than one unbroken line you count parentheses in.
Formulas can read lookups and rollups
A formula can now use a value that lives on a LINKED record. Write CONCATENATE({Name}, — , {Customer city}) where the city comes from the customer, or take a percentage off using a discount that lives on their record, or fold a rollup’s count into a sentence. Until now the field was sitting right there on the row and the formula refused to look at it, which left copying the value into a second field by hand as the only way through. A formula that reaches another table is worked out fresh every time you look rather than stored — so it can be shown anywhere, and it can’t be searched, filtered or sorted on. That limit is deliberate and the editor states it before you save: the same lookup costs nothing when it is working out fifty rows on your screen, and would read every record in the table to answer one filter. Filter on the lookup itself and it stays fast. Two lookups still can’t feed a formula and both say so by name: one carrying its own filter for which linked records count, and one across a link that allows many records, which holds a list rather than a single value.
A formula can build on another formula
Working out a total and then working something out FROM that total meant writing the whole first calculation again inside the second one — and again in the third, and changing every copy by hand whenever the rule changed. Now a formula can just reference another formula by name. Build it up in readable pieces: a subtotal, then tax on the subtotal, then a rounded total, each one naming the one before it. A formula that reads another is worked out fresh every time you look rather than stored, which is a real trade and the editor says so before you save — it is always right, and it can’t be found by search. And a formula that would end up chasing its own tail, however many fields away, is refused with an explanation rather than quietly producing a number that never settles. Lookups and rollups still can’t feed a formula: their values live in another table, which is a different problem and the next one.
You can see who else is in the table
Two people working on one table used to find each other by accident: a cell you were about to type in changed, and that was the first you knew anyone else was there. Now a cell somebody else has selected wears a ring in their colour with their face in the corner, and the cell they are actually typing in wears a light tint as well — so “she is looking at this” and “don’t start typing here” are two different marks rather than the same guess. At the end of the view bar is a row of whoever has the table open, one face per person however many tabs they have, and nothing at all when you are on your own. It is a hint, not a lock: two people can still select the same cell, and what protects the data is the same conflict check as before, which refuses a write that would overwrite something its author never saw. Nothing about it is written down — a face exists for exactly as long as a tab is open, so there is no history of who looked at what.
Search reaches the whole record
Search matched text and nothing else, so what you could see on a record and what search could see were two different things. Now it matches what you can read: the label on a select — searching “shipped” finds the records whose Status is Shipped, even though the cell stores an id underneath and the word appears nowhere in the row — the people a record names, by their name as well as their email address, and the names of the records it links to, so “acme” on Orders finds the orders that belong to Acme Holdings. One step across, never two. Numbers and dates stay out deliberately: a number is stored as 1500 and read as “EGP 1,500.00”, so a term would have to match a value you are not looking at — and a filter answers that question better anyway. The link picker takes the most from this and also takes the most care with it: records the term NAMES come first, all of them, and a card that came up for some other reason says which field matched underneath its title, so a result you weren’t expecting reads as explained rather than random.
A lookup can look up a lookup
Orders links to Customers. Customers looks up its city from Cities. Until now Orders could not reach that city — the field was right there on the customer, and a lookup refused to surface it, so the only way through was a second link you did not want and had to keep in step by hand. Now it works: a lookup can point at another lookup, and the value arrives two tables away with the type it started with — a date is still a date, a price still reads as a price, and a filter set on the lookup in the middle still applies. It stops at two levels on purpose. A chain that can go on forever is a chain that can loop back on itself and sit there working out its own answer; two levels cannot, which is why the limit is the feature rather than a shortfall. Rolling up a rollup is a different question and still isn’t offered — that adds many records together rather than pointing at one.
A paste can widen the table now, not just lengthen it
Pasting a block taller than the table has added the rows to hold it since August. Pasting one WIDER than the table quietly threw the extra columns away — no message, no sign, just fewer columns than you copied. Now it offers to add them: paste four columns into a table with two and it asks whether to make two text fields, and pastes what fits if you say no. It asks rather than just doing it, which is the one place this differs from rows, and the reason is honest — undo takes records back, but a field is a real column in a real database and undo doesn’t reach it yet, so a silent widening would be a mess you had to clean up by hand. Empty trailing columns, the kind a spreadsheet copy usually carries, are ignored rather than turned into fields.
Durations you can type the way you say them
A duration field now takes “1m 24s”, “90s”, “2h”, “2h30” or “1.5h” and means exactly what those look like. Before, the only way in was the full colon shape — typing a minute and twenty-four seconds meant working out that it was 0:01:24, which is a small sum to do in your head every time. There is also a third format: minutes and seconds. A track, a drill, a support call — the short durations — read as 1:24 rather than being dressed up with an hours column that is always zero, and minutes keep counting past the hour there, so ninety minutes reads 90:00 instead of quietly losing one. Colons are read against the format you picked, so 1:24 is an hour and twenty-four minutes on an hours field and a minute and twenty-four seconds on a minutes one. Arabic-Indic digits count as digits. And anything only half-understood is refused rather than guessed at, so a typo can’t become a number you never typed.
Working days, written-out dates, and multi-select in formulas
Three things formulas could not reach. WORKDAY and WORKDAY_DIFF answer “five working days after this” and “how many working days is that” using your database’s own weekend — Friday and Saturday, Saturday and Sunday, one day, or none — rather than assuming everyone’s week looks the same. Change the weekend later and every formula that uses it is recomputed, so nothing is left answering on last week’s calendar. DATETIME_FORMAT writes a date in whatever shape you want it: DATETIME_FORMAT({Check-in}, "DD/MM/YYYY"). And a multi-select can now feed a formula — it arrives as the list of choices it is, so ARRAYJOIN({Tags}, ", ") turns a cell full of tags into one line of text, with ARRAYUNIQUE, ARRAYCOMPACT and ARRAYSLICE for tidying it first. That is 93 formula functions, against the 84 listed in Airtable’s own formula field reference.
Twenty-five more functions, and the time of day
The formula language went from fifty-five functions to eighty. Most of it is the everyday half nobody should have to work around: T and TEXTJOIN for stitching text together, SIGN, COUNTA and COUNTALL, WEEKNUM and DATESTR, TONOW and FROMNOW for “how long since” and “how long until”. The bigger addition is the time of day — HOUR, MINUTE, SECOND and TIMESTR read the actual moment a date-and-time field stores rather than the day it falls on, so “group check-ins by hour” is a formula now. SET_TIMEZONE answers which day something falls on somewhere else, which is the question anyone with guests in another country keeps having to work out by hand. CREATED_TIME and LAST_MODIFIED_TIME give you the day a record was made or last touched, without adding a field to hold it. All of them use your database’s own timezone, and the ones that need a time say so plainly when you hand them a plain date rather than quietly answering midnight. There is trigonometry in there too, which almost nobody will need and costs nothing to have.
Nested IFs, edited as the table you had in your head
A formula that picks between several outcomes — long stay, short stay, one night — gets written as IFs inside IFs, which is the least readable shape a formula has and the thing people complain about most in every product like this one. When your formula is one of those, the editor now offers to show it as a table: one row per rule, each reading “when Nights is more than 7 → long stay”, with the number of records that actually come out that way beside it. That number is counted through the whole ladder, so a later rule never claims the records an earlier one already took — which is exactly the mistake that makes a tiered formula look right and be wrong. Add a tier, remove one, reorder your thinking, and switch back to the formula whenever you like with everything carried across. It offers itself only when it can show the formula honestly: a rule using AND, or a calculation on either side, needs more than the table can say, so it stays out of the way rather than showing you something that isn’t what you wrote.
Formulas know what day it is
TODAY() and NOW() work. “Days until check-in”, “how long has this been open”, “flag anything overdue” — the formulas whose answer changes overnight, which until now needed an outside tool on a schedule. You can filter and sort on one like any other field, so “due in the next week” is a view rather than a thing you scroll for. Nothing is stored: the answer is worked out when you look, which is exactly why it is always right — there is no saved number to go stale and no overnight job that can quietly stop. It also means creating one is instant no matter how many records you have, because there is no column to build. Two things it gives up, and the editor says so before you save rather than leaving you to find out: it can’t be found by search, and a lookup or rollup on another table can’t point at it. And it uses your database’s own timezone, so at one minute past midnight in Cairo it already says today — not in three hours.
Formulas now use your database’s timezone, like everything else
Every date surface in Tabla — the grid, the cell editor, filters, the calendar, colour rules — has worked from your database’s own timezone for months. Formulas were the one that didn’t: they read a date-and-time field on the universal clock, so a check-in at one in the morning in Cairo showed as the 21st everywhere in the product and counted as the 20th inside a formula. They agree now. Date-only fields never had a time to reinterpret and are unchanged. If you change a database’s timezone, any formula reading a date-and-time field is recomputed so it keeps up, and the confirmation tells you how many that is first. And a database you create from now on starts on your own timezone rather than the universal one, which you can still change whenever you like.
See what a formula does to every record before you save it
Writing a formula used to be an act of faith: you saved the field and then went looking through the grid to see whether it had done what you meant. Now, while you are still typing, a line under the editor says what it would do across your whole table — how many records get a value, how many come out empty, and how many DIFFERENT values it produces. That last number is the one that matters. The most common way a formula goes wrong is a comparison that never matches — checking a status against “yes” when the option is spelled “Yes” — and the result looks completely reasonable in the grid while being the same value in every row. “1 different value” across twelve thousand records says it at a glance. Open it up and you get the spread of values and real rows from your own table, including the ones that came out empty, which is usually where the mistake is hiding. None of this creates anything: no column, no field, no lock on your table. And it checks the records in your bin too, because those are the ones the save will look at.
Formulas understand yes and no
A checkbox could not feed a formula, and a formula could not produce one — so the two most obvious things to want, “flag the bookings that ran late” and “only charge when Paid isn’t ticked”, were both out of reach. Now a checkbox reads inside a formula like any other field, and a formula that works out to a yes or a no becomes a real checkbox column: it draws as a tick, filters as a tick, and the footer counts how many are checked. Write it however reads best — {Check-out} > {Check-in} on its own, or AND({Paid}, NOT({Refunded})) — and a checkbox standing alone counts as the condition, so IF({Paid}, …) needs no comparison bolted onto it. An empty checkbox counts as no rather than as unknown, which is the answer people expect and the one the old three-way logic got wrong. Seven more functions come with it: TRUE, FALSE, XOR, REGEX_MATCH, IS_AFTER, IS_BEFORE and IS_SAME.
Sixteen more things a formula can do, including patterns
The formula language went from thirty functions to forty-six. The additions are the ones people were working around: SEARCH, which is FIND without caring about capitals; SPLIT, for pulling the second half of “Cairo, Egypt”; PROPER, for turning a shouted name back into a written one; REPT and REPLACE; SUM, AVERAGE and COUNT across several fields at once; EVEN, ODD, EXP, LN, LOG and PI. And two that change what the field is for: REGEX_EXTRACT and REGEX_REPLACE, which pull a booking reference out of a free-text note, or strip everything that isn't a digit out of a phone number, in one line instead of six nested MIDs. Every one of them is computed by the database itself, the same as the rest — so they filter, sort and export like any other column, and a formula that would produce a number too large to store goes blank rather than stopping the record from saving.
A formula field that starts with an example
Adding a formula opened on an empty slot with a list of thirty function names beside it — a good start if you already write formulas, and no start at all if you don't. It now opens on a short shelf of finished ones written from your own table: days between Check-in and Check-out, Rate per night with 14% added, Guest and Surname joined into one name, a size label that sorts itself out. Pick one and it lands in the editor as ordinary pills you can change any part of; start from scratch and the field list is exactly where it always was. Every example is built from the fields your table actually holds, so a table with no dates is never offered a date formula, and nothing is ever suggested that Tabla would then refuse to save.
August 2026
The board works with a thumb
Moving a card between columns was a mouse-only action: on a phone the board was something you could read and not rearrange, and nothing on screen said so. Now hold a card still for a moment and it lifts, follows your finger, and drops into whatever column you let go over. Holding is what tells Tabla you mean to move it rather than scroll past it, so an ordinary swipe still scrolls the board and a single tap still opens the record. Drag a held card to either edge and the board scrolls itself, which matters on a screen that shows about one column at a time. Nothing changed on a desktop.
A calendar you can actually read on a phone
A month on a narrow screen was seven columns about fifty pixels wide, which is three or four characters of a record name — enough to know something is on the 14th and not enough to know what. On a phone the month is now a row of dates you swipe through, with the day you pick opened underneath it as a list at full width, where names are just names. Tapping one opens the record. Nothing is saved differently: a view saved as a month is still a month, and on a laptop it draws the way it always has.
Sign in with a code when your company's mail opens the link first
A lot of company mail systems check every link in an incoming message before you see it, and the stricter ones load the page properly enough to use it up — so the sign-in link you were sent had already been spent by the time you clicked, and said so. Two things now. The link works for a few minutes and a few clicks rather than exactly once, so a scanner opening it first costs you nothing. And under it in the same email there's a six-digit code: click the link in the browser you asked from and you go straight in as before, and anywhere else — your phone, a work machine whose default browser isn't the one you typed your email into — you type the code instead. It takes about four seconds, and it's the half a mail scanner can't do.
Every database arrives with a face
A new database used to start grey, and choosing a colour and an icon meant a trip into a settings dialog almost nobody took — so a list of six databases read as six identical rows. Now each one arrives already wearing a colour, and an icon picked from what you called it: a database named Invoices gets the card, Bookings the calendar, Deliveries the truck. Nothing is random — the same database always looks the same, on every device and for everyone you share it with — and a name that doesn’t suggest anything gets a neutral shape rather than a wrong one. You can still change both, and the icon picker now has a search box, so finding the right one out of a hundred and eight takes a word instead of a scroll.
Group by a linked record — or a person, a lookup, a rollup
Grouping used to be for the plain fields: text, a number, a date, a checkbox, a single select. Now it takes the ones your tables are actually built on. Group bookings by the property they link to, tasks by who they’re assigned to, invoices by a rollup of what they came to. A cell holding several values — three tags, two linked records — puts its record in one group for that whole combination rather than repeating it in three, so the counts still add up to the number of records you have. Boards can stack by a person too, which is the one column per cleaner, or per owner, that a select field was never going to give you.
A deleted table comes back
Deleting a table used to be the one action in Tabla with no way back. It now works the way deleting records already did: the table leaves your tabs, everything in it stays exactly where it was, and you can put it back for seven days. Restore returns its fields, its views and its links to other tables intact. While it’s gone it really is gone — its forms stop accepting answers and its share links stop opening, and both come back with it. Deleting a whole database is still permanent, and now says so plainly instead of pointing at a backup.
Bring an Airtable base of any size
The direct Airtable import used to stop at fifty thousand records in any one table — which is the size a base has to reach before leaving Airtable is worth the afternoon. It now reads your base a page at a time and writes as it goes, so the only ceiling left is the one your database already has: a million records. Attachments, linked records and select colours come over the same as before, and the progress tells you which table it’s on rather than leaving you watching a bar.
Your export now carries the conversations and the views
The one-click export held your tables, your records and your files. It now also holds every comment — who wrote it, when, on which record — and the configuration of every saved view, so the filters and sorts that are your actual workflow come out with the data instead of living only in Tabla. Comments come out for editors and owners, the same people who can read them in the app. And the attachment ceiling that used to bound a big export is gone: if it’s in your account, it’s in the zip.
Tabla tells you when a webhook stops
A webhook whose endpoint keeps refusing eventually pauses itself, so a broken receiver can’t hold up everything behind it. Until now the only sign was a mark on a screen you had no reason to open, and a scenario in Make or n8n that had quietly gone silent could stay that way for days. Now the database’s owner gets an email the moment it happens: which webhook stopped, where it was pointing, what the last error said, and a link to the button that starts it again. One message per pause, never one per retry.
Search the choices you’re filtering by
A filter on a select field — “is any of”, “has any of”, and the colour rules built from the same row — now opens a searchable list instead of putting every choice on screen at once. What you have picked shows as chips in the choices’ own colours, on a single line however long the list behind it is, and each chip has an ✕ to drop it. Inside the list you can type to narrow it, move with the arrow keys and toggle with Enter, and All and None take the whole list in one click — so “everything except Hired” stops being nine of them. Pick most of a long list and Tabla offers to say it the other way round, turning “is any of” seven choices into “is none of” three, and tells you the one thing that changes before you take it: records with nothing in that field match the second and not the first.
Paste a column of names into a linked record field
Copy a column of names from anywhere — a spreadsheet, another table, an email — and paste it straight onto a linked record field. Each value is matched to a record in the linked table by the name it goes by there, ignoring capitals and spaces around it, and a value that names nothing yet creates that record for you. One cell or ten thousand: filling a link no longer means picking every record by hand. On a link that holds many, a comma or semicolon separates values, so “Cairo, Giza” links both. The count of any records it created in the other table is on the confirmation, never a surprise you find later.
Duplicate a record
Right-click any row, or open a record and use its ⋯ menu, and Duplicate makes a copy — every value, its files, and the records it links to. Select several rows first and it copies all of them at once. A field you have marked as needing unique values comes through empty, since two records can’t share one, and so does a field holding records that belong to one row at a time, because copying those would move them off the record you started from. The copy says which fields it left for you. Cmd+Z takes the whole thing back.
Import a CSV of any size
A spreadsheet export is often hundreds of thousands of rows, and until now a CSV had to arrive in one piece — which meant a size limit. It doesn’t any more. Your browser reads the file where it already sits and streams the rows in, so the only ceiling left is the one your database already has: a million records. You get a real progress bar, a count of what has landed, and a Stop button that keeps the rows already imported. Excel workbooks still come in whole, so those keep their 20 MB limit — saving the sheet as CSV lifts it.
A link in a URL field is a link
A web address in a URL field draws as one now, underlines under the cursor, and opens in a new tab when you click it. Click anywhere else in the cell and it just selects, the way every other cell behaves, and Enter still opens it for editing — so following a link and changing one are two gestures rather than a guess. Only http and https addresses open. The expanded record keeps its editable box and gains a small open button beside it.
The column you sorted by says so
A small arrow in that field’s header, in your database’s own colour — down for descending, up for ascending — with a number beside it when you have sorted by more than one field. Nothing on the rows themselves: a coloured column already means a colour rule matched, and one mark should mean one thing. Opening a view is quieter too — it used to show the previous view’s records for a moment before snapping into the right order.
The API tells you how much of your rate limit is left
Every response to a request carrying an API key now says what that key's budget for the minute is and how much of it remains — on successes too, not only when you're refused. An integration can slow itself down before it hits the wall instead of finding out by bouncing off it.
Attach a file over the API by giving us the link
Putting a file on a record used to mean uploading the bytes yourself, and only after the record existed — two calls, in order, with an id to carry between them. Now an attachment field takes a plain https:// link and Tabla fetches the file during the write, so a record and its photos can arrive together in a single call. It works on create, update and upsert; you can mix links with files already there; and if any link can't be fetched the whole write is refused and nothing is left behind. Uploading the bytes yourself still works exactly as it did.
Read a saved view over the API
The records API takes a view now — by its id or its name — and answers with that view: its filter, its order, its columns. The thing you already set up on screen is the thing an automation reads, instead of a filter rebuilt by hand in a second place and left to drift. Writes got tidier in the same pass: ask for field ids and the reply comes back keyed by field id, so a rename moves nothing at either end, and an upsert now says on each record whether it created it or matched one.
One cookie, one question — for visitors in Europe
In the EEA and the UK the site now asks before Google’s advertising cookie is set, on a small card that blocks nothing and weighs both answers the same. Decline and neither that cookie nor ours is written, and you are not asked again — “Privacy choices” in the footer is there if you change your mind. The card is our own code: no consent vendor, no second script on the page. Everywhere else nothing changed, and Tabla’s own measurement is the same either way: first-party, on our own server, no analytics service involved.
Swiping across a table stopped opening records
On a phone, dragging sideways to read the fields that don’t fit would scroll the table and then open whatever row your finger lifted over — the gesture for reading and the gesture for opening were the same one. A swipe now moves the table and nothing else; a tap still opens the record. The first column gives width back on a narrow screen too, so a whole field fits beside the name instead of a sliver, and the width you set on a laptop is untouched. The table tabs are a single row again, and every row of the view menu is one height, with rename and delete big enough for a thumb.
A table opens on the view you left it on — with that view’s records
Opening a table from the tab bar used to load the first view’s records and then switch to the view you were actually using, which meant a gallery or grid could sit there in the wrong order until you reloaded. The view you last had open is now settled before the page is drawn, so the first thing you see is the right view and the right order.
Hide a column from the column itself
A column’s header menu now carries “Hide field”, so tidying a view no longer means opening Hide fields and finding the right row in a list of twenty. It is the same per-view change either way — the field and its data are untouched, and every other view keeps its own choices. Afterwards the footer offers “Show” for a few seconds, in case it was the wrong column.
A table opens on a third less code
The workspace was downloading things you had not asked for yet — the field editor and the whole formula engine behind it, the record panel, the trash, the calendar and kanban and gallery views — on every table you opened, whether or not you ever touched them. They now arrive on the click that needs them. That is a third off what a table costs to open, and about a quarter off the whole app. Shared views and the sign-in page got lighter too, and the grid stopped redrawing every loaded row each time you edited one cell.
Put your logo on a form — and your colour on everything
A form can now carry a logo above its title, a cover image across the top, and a colour of its own. The colour starts as your database’s and keeps following it unless you choose otherwise, so changing one still reaches every form that never opted out. The link stays the only thing a visitor needs.
Forms stopped borrowing the browser’s widgets
A select on a public form now opens Tabla’s own list of coloured chips instead of the operating system’s grey box, and a date opens the same calendar the grid uses — the two moments a visitor actually interacts with a form were the two that still looked unfinished.
Forms look like they came from you
The public form now wears the brand and your database’s own colour, with real controls instead of browser defaults, and it is built for a phone — which is where most people answer one. The builder is split in two as well: what a visitor sees on one side, the link and who may use it on the other. Questions show their field type and drag to reorder, and a new form starts with a handful of fields rather than every column in the table.
A row with comments says so, in the margin
A small speech bubble beside the row number marks every row that has a conversation, so you can see where the discussion is without opening records one at a time. It sits in the margin rather than over the row, so it never covers the record's name, and it steps aside on hover to leave you the checkbox and the expand button.
Turn mention emails off, if you'd rather
A switch in Your profile. It's the only notification setting in Tabla, because a mention is the only notification — no digests, no watching, no inbox. With it off you can still be mentioned: the mention renders and points at you and is there when you open the record. What you've declined is the email.
Opening a record no longer means a trip across the table
The expand button now sits beside the record's name in the first column, which stays put however wide the table is or how far across it you have scrolled. It used to live past the last column — on a wide table, that was the width of the screen away from what you were looking at.
Forms: a public page that writes into a table
Publish one table as a form, share the link, and anyone can add a record without an account — bookings, sign-ups, intake. Pick the fields, mark what's required, rename the labels for the people filling it in. Submissions are ordinary records, so they land in the grid, fire your webhooks, and sweep through trash like anything else — there is no separate inbox to check. Rate limits, a honeypot and a size cap ship with it rather than after it.
Webhooks and forms are for the people who build
Both now belong to owners and editors, and a viewer sees neither tab. Reading was never the thing being rationed — but the wiring a database is built with is a different question from the data it holds.
Reactions, and an undo on a deleted comment
Four one-click reactions on any comment — got it, done, on it, thanks — because most of what gets said in reply is an acknowledgement, and that shouldn't cost a comment. Deleting a comment now offers Undo for a few seconds, and taking it back returns it exactly where it was rather than as a copy at the bottom. Mentions are a proper pill with a face while you type them, not just once they're posted.
Comments and activity on every record
A record now keeps its own memory: a conversation about it, and a history of who changed which field, from what to what. Change lines are written wherever the change came from — the grid, the API, a paste, an import — and say which. Type @ to mention someone and they get one email with a link straight to the comment. Owners and editors only; a viewer doesn't see the surface, and a public view link carries none of it. This closes the record-comments item on the wishlist.
Five starter examples, each two tables joined by a link
Project tracker, Contacts and Short-stay turnovers each arrive as a pair now — tasks and the people who own them, contacts and the companies they work for, jobs and the properties they belong to — wired together with a link field, using eighteen kinds of field between them instead of seven. Rename a person once and every task they hold follows. Inventory (stock and suppliers) and Invoices (what you sent and what came back) are new. Blank is still blank.
A sign-in link no longer gets spent before you click it
Corporate mail scanners open every link in an incoming message to check where it goes, and that was enough to burn a one-time sign-in link — so the person clicking it was told it had already been used. Opening the link now proves nothing on its own; only the page you land on can spend it.
A profile photo, asked for twice and required never
The welcome screen still invites you to add one, and now genuinely lets you skip it — the page used to insist on a photo to stop showing itself, under copy that called it optional. If you skip it, you're asked once more at the moment it starts to matter: the first time you share a database with somebody.
Your name can't be blanked by accident
Clearing the Name box in Your profile used to save an empty name, which left the app asking for it again on every screen. It keeps the last one you set.
An import ends on your data
Bringing in a spreadsheet leaves you on the rows you just imported, rather than on the empty starter table beside them. Start a database from the Import a spreadsheet card and it now asks what to call it once the rows have landed, instead of leaving "Untitled database" for you to find.
An invitation takes you to the database you were invited to
Accepting an invitation used to sign you in, show you the shared database for a moment, ask for your name, and then deliver you to your own empty gallery. It now asks for your name and takes you straight back to the thing you were invited to open.
91 guides, and a docs hub to hold them
Everything from your first table to what a webhook payload carries, in eleven sections, all readable without an account. The full REST reference came out from behind the login with them, and there's a link to the lot from inside the app.
Download CSV, from any view
One view, one file — the rows its filters select, the columns it shows, in the order it shows them. It streams straight to the browser, so the size of the table isn't the limit. The whole-database zip is still there for everything at once.
Share, in one place
People and public links in a single dialog off the top bar: who has an account here and what each of them may do, and which views are published read-only. The database menu says Share… where it used to say Members… — one word for one idea.
Filters that hold groups, and "is any of"
Species is Dog, or species is Cat and color is orange — conditions nest a level deep, built in the filter panel itself. And a select filter can match several options at once instead of one row each.
Drag to reorder sorts, color rules, and choices
Change your mind about the order of five sorts without rebuilding them. Select choices reorder the same way, with Alphabetize for when the order doesn't matter. Color rules now say what was always true: the top rule wins.
Change a field's type, and the values come with it
Single select to text, text to number or date, checkbox to number, multi-select down to single — every pair with an honest reading converts, all in one transaction, and the editor names what it will cost before it runs. A pair that can't convert says why.
A text column becomes choices, or becomes a link
Convert a text field to a select and every distinct value in it becomes a choice, with each cell moved onto it. Point it at another table instead and you get a real linked-records field, matched by value, with the original column left exactly where it was.
Paste past the last row and the table grows
A paste taller than the table creates the rows it needs, values and all, and a single Cmd+Z takes the whole thing back. Numbers written with thousands separators arrive as the number.
A way to write to us, from inside the app
Contact support in the account menu opens a panel that sends — subject, message, done — and the reply comes back to the address on your account. The address is right there too, for anyone who'd rather write from their own mail.
Imports run at the speed of the network
Attachments copy in parallel, bounded by the memory they use rather than by a rate limit, and thumbnails are built after the records land. A base carrying thousands of files now waits on the wire rather than on us.
Opening a table stopped waiting
Hovering a table or a database card fetches it before the click, a card opens its table directly instead of going the long way round, and the home screen counts every table in one query. The screen you're on stays up until the next one is ready to replace it.
A pass over the whole app, screen by screen
Menus, dialogs and rows move when they change, and stay still if your system asks for less motion. One focus ring across the app, one anatomy for every dialog, nine type sizes where there were twenty-one, one way of showing an empty value. On a phone the controls are thumb-sized and the top bar fits.
A new database starts somewhere
Start blank, or from a project tracker, contacts, or short-stay turnovers — fields, choices and a few rows already in place — or go straight to import. The Tabla mark in the corner is the way back to your databases.
July 2026
Live sync — someone else's edit appears without a refresh
A change made by anyone with access lands in your grid moments later, judged by your own view's filters and sorts: a record that no longer belongs leaves, one that now does arrives. Never on top of a cell you're typing in.
A speed benchmark, timed on the live sites
We measured Tabla head to head — opening, sorting, filtering and searching a 50,000-row table, timed in the browser on each live site. A 50,000-row table opens in about a third of a second: roughly 11× faster than Airtable and 15× faster than NocoDB. The numbers now appear where the claims are made, each with its method stated.
Public view links
Share any saved view as a read-only link — no login needed to read it. The link applies exactly the view's own filters and sorts, so it can never show more than the view does.
A machine-readable API spec
The API reference now has a twin at /openapi.json — OpenAPI 3.1, every path and operation described. Point a client generator at it and skip the prose.
Kanban view, and group-by in the grid
Every table can now open as a board, grouped by any single select — drag a card to change its status. The grid itself groups by a field too.
Summaries in the grid
Sum, average, min, max, and counts along the bottom of every field — computed over all filtered records, not just the loaded page.
Profiles and database icons
Accounts have names and photos; databases have icons and colors. Small things that make a shared database feel inhabited.
A timezone per database
Each database declares its timezone, and the grid, filters, calendar, webhooks, and API all agree on which day a timestamp lands — including across daylight saving.
Duration and unique fields
A duration field that reads h:mm but stores seconds, so it sorts and rolls up like the number it is. And "require unique values" on scalar fields, enforced by the database itself.
Rich long text
Markdown in long-text fields, with clean single-line previews in the grid.
Import: your old database, CSV, and Excel
Connect an Airtable account and bring a base across — tables, fields, records, links, and the attachment files themselves — in one run. CSV and Excel files import with type sniffing that validates everything before writing anything.
Members, roles, and invitations
Share a database by email with owner, editor, or viewer roles. Invitations are single-use and the roles are enforced server-side, on every door.
Trash, undo, and calm concurrency
Deleted records sit in a per-table trash for seven days. Cmd+Z undoes edits, creates, and deletes. Two people editing the same record no longer silently overwrite each other.
Calendar and gallery views
Records with dates stand up as a month; records with images stand up as cards. Views remember their own filters, sorts, hidden fields, and colors.
Formulas, lookups, and rollups
Formulas compute inside the database itself — arithmetic, date math, text, IF — and lookups and rollups read across links and stay current. All three filter; formulas sort too.
The whole-database export
One action: every table as CSV, every attachment's actual bytes, and a machine-readable manifest, in a single zip. The most important feature we'll ever ship.
Webhooks with a delivery ledger
Fire on created, updated, matching, or deleted — with the same filter language the grid uses. HMAC-signed, retried on failure, every delivery logged and replayable.
Earlier work — the grid, fields, linked records, saved views, attachments, and the API — predates this public log. From here on, what ships gets written down.
All of it is live today — free while the beta runs.