Every release since May 2026, newest first — grouped the way we actually shipped it. Everything here is written to be useful, not to be a release note.
Every page and email a stranger sees now takes the whole of your brand rather than just its accent, the one switch that removes our name covers the emails too, and a link that has stopped working lands on a page that explains itself.
Searching a public help centre needs at least six characters. Below that the page came back looking exactly as it had, with the word still sitting in the box — indistinguishable from a broken Search button. It now says the search did not run and that what follows is the whole index.
A form, share link, report, booking page, help centre, chat widget or approval link that is switched off, expired or simply mistyped now lands on one properly designed page saying so in the same words, wherever it came from. It deliberately never says which of those it was: telling a stranger that a link was once real is telling them something they should not learn from a page.
Customer email now prints the plain address under its button, the way our own mail already did. The audience most likely to be reading somewhere that blocks images and mangles buttons — somebody who filled in your form once — was the one without it.
Show "Made with RowFold" in Settings → Branding now governs the customer emails as well as your forms, booking pages, help centre and chat window — a booking page that credited us at its foot while its own confirmation said nothing. It is still one checkbox, still off in one click, and still not plan-gated. Two surfaces were also calling it "Powered by"; everything says the same words as the switch now.
Footers, detail labels and cancellation notes were set in a grey that did not clear the contrast floor for normal text, in every email RowFold sends. Realigned to the colour the app itself uses.
The public help site was the one customer-facing page carrying no shared styling at all. It now wears the same foundation as your forms and booking pages — your logo, colours and typeface — with the search box as the first thing a reader meets, articles as a scannable ruled index rather than a grid of competing cards, and, where a chat widget is installed, a Start a chat card at the foot for the point at which the index has visibly failed.
Describe your business on the front page and the panel beside it now shows your own words and what happens to them next, instead of freezing on whichever worked example it happened to be showing. It still infers nothing from the sentence — reading a brief properly is the AI builder's job, and it needs an account to do it in — but the moment you start writing is no longer the moment the page goes still.
The one-click rating email asked for your logo by a path an inbox has no way to resolve, so every request went out with a broken image where your mark should be. Three places were doing that job separately; they are one now.
The mail your customers get — booking confirmations, reminders, changes, cancellations, form acknowledgements, rating requests, chat transcripts — now takes everything Settings → Branding holds, not just the accent. It sits on your page background instead of a stock grey, sets your typeface on every line rather than ours, and uses a darkened version of your accent for link text so a pale brand stays readable. A confirmation and the page its button opens are now the same colour rather than nearly.
Ask stopped repeating whole paragraphs and stopped explaining its own machinery, everything it names is now a real link, and a dashboard it offers is built with the tiles the answer described.
Asking for a board of bar charts produced an answer promising bar charts and a dashboard opening with KPI tiles, because the layout was a second, separate model call made at confirmation time. The tiles now travel with the proposal, and the confirmation card counts them before you press it.
An answer that took several turns to reach could hand back the same paragraph two or three times, because every turn is generated with the transcript so far and told to carry on. Ask and the AI builder both de-duplicate identical paragraphs before you read them — conservatively, and never in the model's own record of what it said.
A report, saved view, dashboard, automation or table mentioned in an answer is now a link straight to it. The model never handles an id or a URL — it writes the name and the server resolves it against what you personally may see — so a link can be missing but never wrong, and two things sharing a name resolve to neither rather than to a guess.
Ask would occasionally explain what it could and could not reach — server-owned ledgers, tool names — in the middle of an answer about your data, including on workspaces where none of it applied. It answers about your workspace now, and the tool that prompted it says how to tell whether it is relevant rather than leaving a gap to speculate into.
Help articles carry diagrams and screenshots of the real product instead of describing it in prose alone.
Articles across the help centre now carry diagrams where the idea is a shape — how a reply threads, what a posted record seals, the order routing tries — and screenshots of the real product where the answer is a screen. Press F1 anywhere to open the guide for the page you are on.
Queues gained response-time promises with a live clock, automatic pickup, one-click ratings, and a public help centre.
Publish an articles table as a browsable, searchable site at /kb/your-name, under your own logo and colours. It reads the same knowledge base the chat widget answers from, so an article is published to both or to neither.
Give a reply Also set status to and Also assign to, and both happen when it is sent — not when it drops into the composer, so you can still edit the text first.
A weekly pattern and closed days, at Settings → Business hours. A policy can count its targets during business hours only; a workspace that has stated none keeps counting around the clock, because that is the honest reading of a workspace that has stated none.
When a ticket reaches a finishing status, the person who wrote in is emailed a one-click 1–5 rating under your own brand, after a delay you choose — because a ticket is often marked solved a beat before the customer agrees. One ask per ticket ever, a per-customer cooldown, and the scores gather on the queue's How did we do page.
Set how fast a queue owes a first reply and a resolution, from Response times on the table page. Every conversation in the Inbox then carries the clock — a countdown, Held while a status like Waiting on customer pauses it, Late once a promise is missed — and a Late filter appears on exactly the queues that promise one. Deadlines are stamped when the clock starts, so tightening a policy later never rewrites history.
Open a conversation and the thread says who else is viewing it, with typing dots while a teammate writes — so two people stop answering one customer at once. Visitors never see any of it.
A new, unclaimed ticket can be assigned as it arrives: the customer's usual person where one can be established from the address, otherwise whoever has had the least work lately. It never overwrites a claim — assignment is an offer, not an argument — and people who leave the workspace drop off the roster on their own.
Signing up with a template now says so, templates wear plain names on the things you own, and the funnel's dead ends got real pages.
Type a sentence in the hero, then pick a template at confirmation, and the sentence used to vanish. It now parks under the card — Set aside — with Use my brief instead one click away. The steps read Confirm → Build → Invite, which is the order things actually happen.
Links work once and expire after 30 minutes; opening a used one now says exactly that, with your address prefilled and a fresh link one click away — instead of a red error on the request form.
Arriving on Home after a build finished used to meet the full build card — phases, counts, twenty artifact rows. It is now one line, Built just now — 4 tables, 3 links, 325 records — with the whole list one disclosure away and the dismiss where it always was.
Arriving at sign-up from a Use this template button used to be greeted with the AI pitch — "no canned schema has been selected" — while the wizard quietly honoured the pick anyway. The page now names the template, shows its tables, and keeps the AI builder as the alternative rather than the denial.
The gallery's worked examples keep their character, but the card you confirm at sign-up now says what a template is — Veterinary practice, not Cedar Veterinary — and a first build files its tables under your workspace's name instead of the demo company's.
Trip the sign-in rate limit in a browser and you get a RowFold page — what happened, a countdown, a way through — rather than a raw JSON error. API callers keep the JSON contract, now with the limiter's real retry time.
Every view now shows everything it claims to, reports gained a time dimension, and a dashboard answers a question by being clicked.
Report filters now run in the database, before the row limit rather than after it. They used to be applied at the end of a run, over records already cut to the first 20,000 in alphabetical order — so a report filtered to one region over a large table quietly answered from whichever records happened to sort early. On a 25,000-record test table where every one of the 3,000 matches sorted late, that report returned nothing at all. It now returns all 3,000, with the exact total. Where a filter is one the database cannot run — anything reading a lookup, a rollup or a formula — the old limit still applies and the page says so, which is the honest half of the same change.
Pick the date that decides whether a record counts — ordered, shipped or paid are three different answers, so RowFold asks rather than guessing — then pick one of eight windows: this month, last month, this quarter, this year, the last 7, 30 or 90 days, or the last 12 months. Then compare it: against the period before, or against the same period a year ago, which is the one a seasonal business actually wants. Growth from nothing says “up from nothing” instead of inventing a percentage, and a group that wasn't there last time reads “new”. Periods are resolved on the workspace's clock, so two people in different countries see the same set.
Subscribe to any report and it lands in your inbox every day, every week, or on the 1st, as a PDF or a CSV, at an hour you pick in your own timezone. Subscriptions are per person, so subscribing does not sign your colleagues up, and it is computed with <em>your</em> permissions — a report sent to you can never contain a column you would not be shown on screen.
Click <strong>Won</strong> on a dashboard chart and every other tile reading that table narrows to Won deals. Click it again, or press Escape, to clear it — nothing is saved, so the next person to open the board never inherits your selection. The chart you clicked keeps all of its bars, with the one you chose picked out, so you can move the selection without starting again. Every tile says whether the filter reached it. Usually that is most of the board; the ones it could not reach say why: an activity feed is not a total, a saved report carries its own filters, and another table's records are not what “Stage is Won” is about.
Group down the side and along the top, and pick the one number that fills the grid: revenue by region by quarter, in one table. An empty cell reads —, never 0. Nothing landed there; that is a different fact from a measured zero, and the CSV leaves it blank for the same reason. Totals are computed over the records themselves, so an average column doesn't turn into an average of averages.
Six surfaces were reading the most recently edited slice of a table and drawing it as though it were the whole answer — so what you saw depended on what somebody else had edited lately. On a 25,000-record table a month of the calendar drew 120 of its 1,500 events; a board column holding 5,000 records captioned itself 40; a map filtered to one record found nothing. Each view now has a limit it can name: lists scroll, and a board scrolls per column; the calendar and the timeline load the period on screen; a tree picks its parents and then loads all of their children; a map follows the filter, so narrowing actually helps. A few places still have a hard ceiling — reports, mostly — and those say so on the page.
An ordinary filter narrows the records — “deals over £10,000”. This narrows the groups: “only regions that billed over £10,000”, a question you could not put to a report at all before. It uses the same filter builder, because a grouped row is still a row, and the column totals below always match the rows above them.
Share a report with a client or a board member who has no RowFold login, at an unguessable URL, with an optional expiry and an optional CSV download. The link starts switched off until you turn it on. What makes it safe is that the columns are frozen at the moment you publish: add a column later and it is not merely hidden from the page, its data is never computed for a public request at all. Re-publish when you mean to widen it.
The day somebody actually has to run — a column per person, drag to reschedule, and a tape chart for anything booked by the night.
Changing a service from 90 minutes to 120 no longer re-draws appointments that were taken, delivered and invoiced at 90. The length is written onto the booking at the moment it is made and read back from there. If a table has nowhere to keep a length, the scheduler tells you. It will not quietly draw every appointment the same size and leave you to notice.
A Scheduler view is a booking page read backwards: the table your public page writes one appointment into, shown as the whole day somebody has to run. A column per staff member, drag an appointment to move it, drop it in another column to reassign it, check people in as they arrive. Rescheduling and cancelling send the visitor the same emails your booking page would, and every result names who was told. Where there was nobody to tell, it says so — the one thing it will not do is let you assume a message went out. A “Needs a decision” queue collects the two problems the data can prove on its own: nobody assigned, and two bookings on one person at once.
A cottage, a boat, a room — anything with a check-in and a check-out where another table would have a start time — lays out as a row per unit and a column per day, with bars stretched across the nights. The checkout day is free: a cottage handed back on the 8th can be taken on the 8th, Read it the other way and probably every back-to-back booking you have ever taken shows up as a double-booking.
Bring a whole Airtable base across without duplicating it, connect five more of the tools you already run, point an AI assistant at the workspace, and share the work out.
Four new steps. <strong>Wait</strong> and <strong>Wait until</strong> pause a run and resume it later as the same run, re-reading the record when it wakes, so it acts on what is true then. An hour-old copy of the record is exactly what you did not want. <strong>Only continue if</strong> puts a gate in the middle of a chain, where before you could only bolt a condition onto the trigger. <strong>Find records</strong> runs the rest of the chain once per record it finds. And <strong>Ask the AI</strong> puts a model in the middle of an automation with the same read-only toolbelt Ask already uses. Schedules can now be monthly.
Linked records come across as real relations, matched on Airtable's own record ids. Attachments are downloaded before their URLs expire. Hit a rate limit and the import waits it out; nothing is dropped on the floor. Run it twice and the second pass updates what the first one brought over. No second copy of everything, so you can keep running it while you make up your mind. It brings up to 100,000 records per table and says so plainly when a table was bigger. Large CSV imports moved to the same background job, with progress you can watch.
<code>My Work</code> collects what is assigned to you, what you are watching and what is waiting on your approval, across every workspace you belong to. Assigning somebody now starts them watching the record too, so the next comment reaches them without anyone remembering to do anything about it. Home grew a team roster beside it.
Type a name that is not in the workspace yet, in a mention or a People field, and you can invite them from there — as a Viewer, never anything more, because an invitation sent mid-sentence should not be able to hand out edit rights by accident.
A one-way hourly mirror from Airtable, so the base you are leaving stays in step with the workspace you are building — nobody has to switch on a Tuesday and hope. Turn it off when you are ready. The mirror stops; nothing is unwound. There is a page for the whole route at <code>/migrate</code>, per source.
<code>@me</code> is now a filter value in its own right, so a single shared view called “Assigned to me” answers per person who opens it. One view to maintain where you used to need one per teammate, and somebody who joins next month gets theirs by existing.
Five more connectors you can authorise with your own account and nothing else — no client ID to register, no developer app to create. They join Airtable, Google Drive and Xero, which makes eight you can connect in one click. Another sixteen take an API key you generate yourself, so those work today too. The rest are built and waiting on us to register an application with the vendor — the “Needs setup” badge in the gallery means that, and it is ours to do, not yours.
A watchpoint is a saved number and a threshold — “overdue invoices above ten” — checked every hour, that emails you when it <em>crosses</em>. Not while it stays there: an hourly “still above ten” for a fortnight is how people learn to ignore alerts. You author one from the view toolbar, so the thing being watched is literally what you were looking at, and it belongs to you, not to the workspace — your permissions decide the number, and two people watching the same thing are two separate alerts.
RowFold speaks MCP, the protocol Claude, Cursor and other assistants use to reach tools, so an agent gets twelve read tools — search, schema, filtered queries, exact aggregates, a record's history, its comments, its attachments, why an automation did or didn't run — and, if you allow it, three that write. A connection is bound to a person, so it can never see or do more than that person could: no-access tables stay invisible, hidden fields stay hidden, and the audit trail names the connection and the person it acted for. Write access is a separate switch you turn on when you make the key, and every write can be dry-run first.
The clock, the column headings and the maths all say what a person would say — and a phone scrolls again.
If you had the chat widget on your site, every inner scroller on the page under it was dead to touch on an iPhone — the record grid's sideways pan, the drawer, the rail. The widget's closed panel was keeping its full box: an invisible, full-viewport frame that iOS hands every scroll gesture to, however transparent it is. Closed is now 0×0. It looked fine in every emulator and on every desktop browser, which is why it took a real phone to find, and the diagnostics built to chase it stay in the product for the next time.
<code>{Check out} - {Check in}</code> is the number of nights. <code>{Start} + 7</code> is next week. Formulas now do date arithmetic in days, so the most natural thing anyone can write over two dates finally computes. It used to answer “Expected a number but got a date” on every row of the table. The difference is exact, not rounded, so multiplying by 24 gives you real hours, and <code>DATEDIF</code> now agrees with it to the digit.
A record's name is its first field's value — that has always been the rule, and the column at the left of every grid was quietly not following it. Anything created outside the grid (an import, a form, the API, a connector, the AI builder) could set a name and a first-field value that disagreed, and forty-odd creation paths did exactly that. Field one now wins, everywhere it is read: the grid, the shared view, the CSV. The rows already stored were re-derived in place, and nothing that could not be reproduced was thrown away.
One o'clock in the afternoon now reads “1:00 PM” wherever a person sees a time — the calendar, the scheduler, booking pages, confirmation emails, automation messages and every settings log. It used to be three different formats on three screens of the same product, and the one your customers saw was the 24-hour one. Stored values, exports, the API and anything you type into a time box are unchanged: this is how a time is shown, not how it is kept.
Webhook In publishes the format and turns every JSON POST into a record. Maps learned to pin by an address stored on a related table, and the calendar, board and gallery finally draw the fields the view was told to show.
A booking is not at an address — the property it booked is. Stored properly that address lives on Properties, which used to leave a map of Bookings with nothing to read and one way out: copy the address onto every booking with a Lookup column, purely to make the map legal. A Map view can now travel the link instead and pin each record where its related record is, with no column added to anything. Pick it from "Pinned by" above the map — which can be asked again later, unlike the setup card it replaces, so a table with two address fields no longer lets you choose wrong exactly once. Where a link reaches several addresses you get a pin for each, rather than the first one and silence about the rest.
Making a folder from the sidebar's own folder button saved it and then did not draw it, because the sidebar worked out whether you could see a folder by looking at the tables inside it — so a folder with nothing in it read as one you had no access to. It vanished from the sidebar, and since the "Move to..." menu is built from what the sidebar drew, it was unreachable as well: the only folder anybody could actually make was one made through a table. An empty folder is now judged on its own terms, and a private one still keeps its name to itself.
Every view has a Fields control, and the calendar, board and gallery all ignored it — an event was its name and nothing else, however much you had told the view to show. They now draw the fields you picked: on month pills, on day and agenda rows, inside the hour grid's blocks, and on board and gallery cards. Anything already obvious from where the event sits is left out rather than repeated, so an event does not print the date it is on or the lane it is in. Linked columns work here too, so a booking can show the client's phone number without that column existing on Bookings at all.
The token in the URL is the baseline credential. Per endpoint you can additionally require a signature — the same scheme RowFold already signs its outgoing webhooks with, so a partner who verifies our deliveries reuses the code they have rather than learning a second format. The secret can be rotated without changing the URL, and a repeated Idempotency-Key replays the original answer instead of filing a second record, so retrying after a timeout is safe.
A board groups records into columns by a select field. It can now also split into rows by a second field — owner, priority, client — so "what is in progress" and "whose" are answerable in one glance. Dragging a card sideways moves it along the columns, dragging it down moves it between lanes, and a diagonal does both in one gesture; only what actually changed gets written. Lanes are set up on the board itself, because that is the only screen where you can see what one would do.
Email In, for machines. Give a table an endpoint and every JSON POST to its URL becomes a record. What separates it from an automation webhook is which side decides the format: here RowFold publishes it, so the setup page renders the exact body for your own field names, ready to copy, with a curl command beside it. It answers immediately rather than later — 201 with the new record's id, or a 400 that names each field it could not accept — because a sender following a published contract should hear "no" at once, not discover it in a log it cannot see. The envelope is the same one the REST API's create uses, so outgrowing the endpoint means moving to the API without reshaping anything.
The lifecycle builder now opens on a proposal built from your own field — its real options, its real record counts — instead of three presets that had nothing to do with your data. And RowFold works on a phone.
Setting up a lifecycle used to offer three presets that had nothing to do with your data, then bolt their states onto your dropdown beside the ones already in it. It now opens on a proposal built from your select field's own options, in their own order, with a live count of how many records are sitting in each, and a starter set of moves between them — all of it editable before anything is saved. It guesses which field you meant, too: proposing a Contacts table's "Role" over its "Status" read as not having looked.
The proposal knows about 120 status words across sales, support, recruiting, logistics, invoicing, manufacturing, legal and events, and uses them to guess which of your options mean not started, in progress, done, and did not happen. "On hold" and "In review" stay in progress rather than reading as finished, "Not approved" cannot come out as approved, and "Won't fix" is understood. Where a word is genuinely ambiguous it deliberately stays in progress — Archived, Invoiced, Overdue and Offer are all guesses somebody would have had to undo.
Signed-in pages could not scroll on a phone at all: the app shell was pinned to exactly one screen height with everything past it unreachable, which also meant the browser's own chrome never got out of the way. A table opened showing fewer than two rows on a small phone, and most pages could be panned sideways into empty space. Forty-eight pages were measured at phone sizes and the five underlying causes fixed — a table now opens on about twelve rows, nothing pans sideways, and tapping a field no longer zooms the page in on iOS.
$29 per editor, flat, from the first one. No platform fee, no minimum, no band to cross. Viewers stay free and unlimited, AI past the included allowance can be metered rather than blocked, and email stops at addresses that have already bounced.
The old plan charged $99 whether you were one person or three, which meant the worst price-per-value landed exactly where most workspaces are. It is now $29 per editor with no platform fee, no included band, no minimum and no maximum: one editor is $29, three are $87, ten are $290. Viewers stay free and unlimited, and there is still no feature gating — every workspace gets everything.
Each editor brings 500 AI actions a month, pooled across the workspace. When they run out AI still stops — that has not changed, and is deliberate. What is new is that you can opt in to carrying on at $5 per 100 actions, with a monthly ceiling you set, above which it stops exactly as it would have anyway. Off by default, and that default is the point: metered spend that switches itself on is how people get a bill they never agreed to.
An address that hard-bounces or reports spam is added to a suppression list and skipped on every later send, because continuing to mail a dead address is how a sending domain loses its reputation for everyone using it. The log says suppressed rather than sent, with the reason and the date. The distinction that matters is kept: a full mailbox, or a server that was briefly down, is ours to retry rather than the recipient's fault, and suppresses nobody.
A booking page publishes your availability and writes appointments into the tables you already have. Text messages became a channel of the platform, with the consent rules that choice makes mandatory.
Replying STOP stops the texts immediately, with no signature check — a forged STOP only stops messages somebody can turn back on, whereas waiting to verify one risks texting a person who has asked you not to. START is the other way round and does require a valid signature, because a forged one would resubscribe somebody who opted out. Opt-out is keyed on the number itself, so it holds everywhere at once rather than needing to be repeated.
Publish a booking page and people pick a slot without an account. It reads and writes the tables you already have rather than a private booking store of its own: the appointment time, the service, the staff member, the client and the status are each mapped to a field you choose, so a booking is an ordinary record the moment it lands — filterable, reportable, automatable, and on the same calendar as everything else. Duration and price come off the service, and availability is a rota you keep as rows. Busy time counts what is already in the table, so an appointment typed straight into the grid occupies that person exactly as a public booking does. Whoever booked gets a link that lets them reschedule or cancel without an account either.
SMS is a channel of the platform rather than a booking feature: the same notification settings that decide what reaches you by email now decide what reaches you by text, and automations gained a Send SMS step. It is deliberately not everything you allowed — only the kinds worth interrupting somebody for, so being assigned something texts you and a watched record changing does not. A phone number on file is contact detail rather than consent, so the setting starts off and has to be turned on.
A booking page can fix the staff member, let the visitor choose one, offer "anyone", or offer both — drawn from an explicit roster rather than everybody who happens to be in the table. When somebody picks "anyone", their preferred staff member is honoured first and the least loaded takes it otherwise.
Ten kinds of thing carry data across the edge of a workspace, and each was visible only on its own page. Channels answers the question none of them could: what of ours is reachable right now?
A form, an Email In address, a Webhook In endpoint, a chat widget, a booking page, an automation webhook, a connector, an API client, an outgoing webhook and a shared view link all carry data across the edge of your workspace — and each was visible only on the page that built it, so nobody could answer "what of ours is reachable right now?" without opening nine screens. Channels is that list. Every row names the table it writes to, its public address, whether it is Public, Live or Paused, when it last did anything and how much has come through. It changes nothing itself: each row links to the page that already owns that surface. Admin-only, because for the surfaces that answer without a login the address is the credential.
"3 need attention" used to be a number you read and then went hunting for. Click it and the list narrows to exactly those three, each carrying the reason beside it and a link to the page that fixes it.
"How do I cancel this?" is unanswerable without knowing what "this" is. A chat now arrives carrying the page the visitor was standing on, its title, and whatever your own site chose to attach — a plan, an order reference — with a marker in the thread wherever they moved on mid-conversation. Your site tells us this, so the thread says as much, and the one thing the browser itself can vouch for is shown apart from the rest.
A visitor asking "how do I cancel this?" was asking about a page you could not see. Conversations now arrive with that page and its title on them, shown at the top of the thread — and if the visitor moves around while you talk, a marker appears between the messages saying where they went. Point it at a field as well and the page becomes a column, so a queue can be filtered and grouped by where chats are coming from.
Plenty of real URLs carry a session token, a sign-in link or a customer's email address after the question mark, and a support table is no place for any of them. So everything after the ? is dropped before the page is recorded, unless you turn it on for a widget that genuinely needs it. What is after the # never travels at all. And because the chat window cannot see the page around it — your site tells us — the thread calls that address reported by the page rather than proven, shows the site the browser actually loaded the chat from beside it, and stops offering the address as a link when the two disagree.
One line on your site — RowFoldChat.setContext({ plan: 'pro', orderId: 'A-1183' }) — and those values arrive beside the page, on every conversation from that visitor. Whichever of your own identifiers would have been the agent's first question. They are visible to anyone who can open the ticket and are stored with it, so send what identifies a customer to you rather than anything you would not put in an email about them.
The emails your workspace sends are now written in a proper editor and rendered beside RowFold's own wording before they go — from a real record, so you can tell whether a merge field actually resolves. And once they have gone there is a log of every one, in and out, that says whether it was delivered, bounced or opened rather than only that it was handed over.
Settings → Email log lists everything your workspace sent and everything that arrived at your Email In addresses, with a Problems only filter for the question people actually ask. Click a row to see the message as it was sent. Mail that came in and was deliberately dropped — an out-of-office with no conversation to join — is logged with the reason, because a silent drop is indistinguishable from an email that never arrived.
The log now takes delivery reports from the mail provider, so a row can say the receiving server accepted it, that it hard-bounced and why, or that it was opened and how many times — rather than stopping at “we handed it over”, which is the weakest thing an email log can tell you. The page is honest about the limits: delivered does not mean read or even inboxed, opens are counted by a tracking pixel that some clients never load and others load without a human, and replies you send a customer carry no pixel at all.
A sign-in link signs the reader in. A reset link resets the password. An approval email carries buttons that decide on somebody's behalf. Those bodies are not kept in the log at all — an admin screen that stored them would be a way to take over an account, and that risk arrives the moment a log exists rather than being mentioned in any feature request. Who it went to, when, and whether it arrived are all still recorded. The rule is an allowlist, so a mail type added later withholds its body until somebody decides otherwise.
Bold, italic, links, bullets, numbered lists, headings, a quote, a button and a divider — with merge fields dragged in as chips that read the field's name instead of a row of curly braces. What is stored is a document rather than markup, and RowFold renders the email from it, so what arrives is the same inline-styled layout as every built-in RowFold email rather than whatever a browser's editor happened to produce. The plain-text version every mail also needs is derived from the same document, so it can never drift from what you wrote.
Email wording used to be two boxes of plain text and an act of faith. Each email now renders live beside the editor — twice, from the same real record in your workspace: your version and RowFold's built-in one, so the only difference on screen is the difference your edit makes. It draws the whole email, including the parts you cannot edit, which is how you find out that your wording is the opening of a message rather than all of it.
A $300 deal now reads as $300 to everyone who opens it, instead of taking its symbol from whoever is looking — the same number under a different sign is a claim about a different amount of money. Teams holding more than one currency can say so, mark the columns, and supply the rates; anything that adds money up then converts each record at the rate in force when it was created.
The currency on a record used to come from the READER's preference, so a deal recorded at $300 showed as £300 to a colleague in London — the same number, a different symbol, and nothing converted. That is not a different presentation of an amount, it is a different amount. A workspace now says what its money is in (following whoever owns it unless you pin one), and every surface takes the currency from the data. Your own setting still decides how numbers are punctuated — 1,234.50 or 1.234,50 — which genuinely is yours.
Tick “we record money in more than one currency” and each money column can carry its own; leave it off and nothing anywhere ever asks you to pick one. That gate is the point: until a team genuinely holds several currencies there is exactly one in play, no picker exists on any field, and no rate is ever requested. Rates are yours to enter — a pair, a number, and the date it took effect — and RowFold deliberately does not fetch them from a market feed: a live rate moves every second, carries a spread it cannot see, and would make a figure on your screen change with nobody editing anything.
A Currency column in a report printed 32000 where the same record read $32,000 on the grid, and a Percent printed 42 instead of 42% — the same data contradicting itself between two pages. Reports now format an authored field by its type, the way every other surface does.
Adding dollars to pounds gives a total of nothing, so wherever money is added up — a column total on the grid, a group subtotal in a report, a KPI or chart tile on a dashboard — each record is converted at the rate in force when IT was created, then added. Not today's rate over the whole total: that would make last quarter's figure move overnight. Only the total converts; the rows keep the currency they were written in, so you can always see what was actually recorded. And nothing is guessed — where a pair has no rate the grid says “Mixed currencies” and a report prints the shortfall under the number, rather than quietly totalling the rows that happened to convert.
The schema map became something you can actually work in — drag the tables where they make sense to you and they stay there. And RowFold will now look over the whole workspace, data included, and tell you what would make it stronger: a column that is really a date, a total a customer should carry, a set of columns that were always a table of their own. Each one shows what it would do before you commit, and applies in a click — on the map, or on the toolbar of the table it is about.
The map of your tables and the links between them is now laid out properly, and you can drag any table where you want it — the arrangement is saved for the workspace, so everyone opens the same picture. Click a table to focus it and read its fields and relationships in a panel beside the map; search to find one in a large workspace; zoom and fit to the window. Arrows show which way a link points, whether one record may hold many, and which side owns the other.
Ask RowFold to review a workspace and it reads the shape AND the data — how full each column is, how many distinct values it holds, what those values actually look like — then proposes changes worth making. A text column whose values are all dates. A column with eight repeated values that wants to be a pick list. A total a parent should carry from its children. Columns that are really describing a separate thing, which it will extract into its own table and migrate the data into. Every suggestion quotes the numbers behind it, and says what it would do to your records before you decide — including the most reassuring fact about most of them, which is that changing a field's type rewrites nothing and can be changed back. Apply in one click, or decline it for good. It cannot nag: anything you have already done, by hand or by import or over the API, retires its own suggestion without you ticking anything off.
Advice about the Companies table is worth more on the Companies table than on a diagram you have to remember to open. Once a review has run, any table with something outstanding carries a quiet button on its toolbar — on the grid, and on the calendar, timeline, tree and map views too — which opens the same card with Apply in place. It shows up only when there is something to say about that table, and it only ever carries advice whose evidence still holds: change the schema, or add or remove a meaningful number of records, and it stands down rather than recommending something worked out from a workspace you no longer have. The map keeps showing the review after that, with the reason it is out of date and a button to run another.
Column widths, what stays pinned, how tall a row is and what sits at the foot of a column all became part of the view — so they travel to everyone who opens it, including people with no login. The 200-row pager is gone, and a column from the table next door can be shown without touching the schema.
A view can now show a field that lives on a RELATED table — Company → Region, Supplier → Lead time — as an ordinary column, without adding anything to the schema. This is the half that was missing: you could already narrow a view by "Company → Region is East", and then had no way to SHOW Region and check the filter was doing what you meant. Same picker, same route, now with a column at the end of it. It is deliberately not a substitute for a Lookup field: a Lookup is a decision for everyone, in every view, in the API and in exports, which is why creating one stays an admin act — a linked column is one view's lens, so any member can add one to a personal view. Up to eight per view, because each one is a real lookup per page of records rather than a free display trick. It sizes, freezes, reorders and exports like any other column; it can't be sorted or totalled, because there is nothing stored to sort or total.
A lookup or rollup that has to read an enormous number of linked records stops at 50,000 and works from what it has. It always did — but it presented the result as if it were complete, which is the one kind of wrong a number can be that nobody checks. Those cells now carry a small ≈ with an explanation on hover. The exported value is left clean, so a spreadsheet can still add it up.
Any rolled-up number in the grid opens the records it was made from — the five deals behind £429,000, with what each one contributed. It opens on the same stack the record drawer uses, so clicking one goes into it and “Back” returns to the list. If the rollup only counts some records — the posted ones, the won ones — you get exactly those, because it is the same working-out that produced the number rather than a fresh guess at it. Charts have answered “which records is this made of” for a while; the grid does now too.
Column widths are part of the view now. Drag the edge of a header to size a column, or double-click that edge to fit it to its content. Because the width belongs to the view rather than to your browser, it travels: to your laptop, to your colleagues, and — the case that actually matters — to a view you've published at a public link, where the layout IS the artefact and there is no browser of the reader's to remember anything. It used to live in this browser's local storage keyed by TABLE, so two views of the same table fought over one set of widths and nobody else ever saw yours. Sizing a shared view is a view edit, so it takes the same permission as hiding or freezing a column; anyone else still drags freely and keeps their own widths locally.
Selecting rows and exporting them used to build the file in your browser out of what was on screen, and it got four things wrong quietly. A link column wrote the linked record's internal id instead of its name. People and attachment columns leaked their stored shapes the same way. Lookups, rollups and formulas exported a header over an empty column, because those are worked out as the page loads rather than stored. And it could only ever write the rows the browser had loaded — so after “select all 40,000 matching” you got a file of the 200 on screen, with nothing to tell you. Both exports — the toolbar's and the selection's — now come from the same place on the server, produce the same columns in the same order, and are recorded in the audit log.
Freezing is now a boundary rather than a switch: the column menu offers "Freeze through this column", so you can hold the first three still while the rest scrolls sideways, and any column can be the edge. It also defaults to nothing frozen — the old behaviour pinned the first column whether or not that helped. The boundary counts columns as the view renders them, so reordering or hiding one moves it with the layout instead of stranding it. Row height gained two rungs above Comfortable and Compact: Tall shows two lines of a long cell and Extra tall shows four, wrapping rather than truncating, because a wrap setting at 36px has nowhere to wrap to. Taller rows also draw more of a link field's chips before they collapse into a count.
The grid loads more rows as you scroll instead of asking you to click Next. Nothing about a row changes when it arrives that way — the same markup renders the first screenful and the thousandth row, which is what keeps permissions, computed values and formatting from quietly diverging below the fold. One long-standing bug had to be fixed for it: the underlying order wasn't total, so records written in the same import shared a timestamp to the microsecond and a page boundary could hand you one row twice while skipping another. It always could; paging just landed the duplicates far enough apart that nobody compared them.
Describe a business and the AI now models the connections properly, not just the tables. It can pull a value from two or three links away — a project's client's region — instead of copying a column onto every record to bridge the gap. It can total children onto a parent through an intermediate table: line items summing onto a customer through their orders. It can count or total only the records that match a condition, including a condition that travels a link. And when you ask it for a report, it can put a related record's field straight in the report, without anyone adding a field to the schema first. It also learned some taste: derive a total on the side that answers the question, don't invent a column that exists only to make a route work, and name a field for the answer — “Open pipeline”, not “Sum of Deals Amount”.
Every column can carry an aggregate in a row pinned to the bottom of the grid — sum, average, min, max, median on numbers; earliest and latest on dates; checked, unchecked and % checked on checkboxes; and filled, empty, % filled, % empty and unique values on anything. Start from Summarise in the toolbar, or the column's own menu. The number is computed by the database over every row the view MATCHES, not over the rows currently on screen — which is the whole point of having it, and the reason it doesn't climb as you scroll. Grouped views put each group's totals in its HEADER rather than a trailing row, so the figures stay visible when the group is collapsed, which is where a group total earns its place. Lookups, rollups and formulas can't be totalled and the cell says why: they're worked out per row as the page loads, so there's nothing stored for the database to add up. An empty result reads "—" rather than 0, because 0 is a claim about your data.
A linked column can follow a link that reaches MANY records — a customer's orders, a deal's activities — and it never turns one row into six. It asks what you meant instead: list them, or count them, or total, average, min or max a number across them. And it can narrow what it counts: “only the orders that are posted”, or “only where the contact is in the US” — a condition that travels a link of its own, so the thing you are filtering on can live where it belongs instead of being copied onto every child record. Listing is still there for the cases where the names are the answer; up to 25 are shown before the rest become a count.
The field editor looked like one form and behaved like one form per row. Renaming three fields and pressing Save on one DISCARDED the other two — the page reloaded every row from the database and the typing was simply gone, with nothing on screen to say it had happened. A confirmation box had been added at some point, which made the loss deliberate rather than impossible. It is one form and one Save now, and the answer to "I changed several things and pressed Save" is that they were saved. When one row is refused — a name collision, a formula that won't compile — nothing in the batch saves, and the page comes back with your typing intact and the reason sitting beside the row that caused it, instead of reverting your work silently.
A date field can carry a time, the calendar grew an hour grid you can drag events around, and a workspace now says which zone its work happens in — which is the clock scheduled automations and "due in the next 7 days" had quietly been getting wrong.
When the date field behind a calendar carries a time, day and week views draw an hour grid and place events where they belong on it, instead of stacking everything into an all-day band. Drag an event to move it, drag its lower edge to change how long it runs, and it snaps to sensible increments. Day view splits into lanes — one column per person, room or machine — which is the rota read. Month and agenda stay as they were on purpose: thirty hour grids side by side is thirty columns of slivers, and an agenda is a list where a time is a label rather than a position.
Turn on "Include a time" for a Date field and its cells hold a time of day as well as a date, with the editor and the pickers following automatically. Sorting, filtering, grouping and relative windows like "in the next 7 days" all keep working untouched. Turning the setting back off leaves every stored time alone and still visible — a config box must never quietly wipe a column, and hiding the times would look exactly like having done so. There's a second setting underneath it for the case that actually needs deciding: whether these times CONVERT into each reader's own zone. Off — the default — means the time belongs to a place: a shift starts at 9:00 AM at the site, whoever is looking. On means it belongs to the people in it: a call at 3:00 PM London is 10:00 AM for New York, and each sees their own.
Every other way a date gets into RowFold — typing in the grid, a CSV import, an automation, an email, a public form — normalises it to one of two shapes before storing: a plain date, or a date with a time. The REST API did not. It kept whatever text the caller sent, so a spreadsheet export writing “2026-05-18 10:00:00” and a browser client writing “2026-05-18T10:00” put two different strings in the same column for the same moment. It looked fine, because RowFold reads dates tolerantly, and that is exactly what hid it — right up until something compared the stored text rather than the date, and two cells meaning the same instant failed to match. The API now normalises like everything else, and refuses text that is not a date instead of storing it. It also refuses a date carrying a time zone — “09:00Z”, “09:00+01:00” — because a record date is wall-clock time on your workspace's own zone, so an offset has no meaning here and quietly converting one would be a guess. Send the wall-clock time and it is stored exactly as meant.
Settings now carries the zone your work happens in, and it defaults to the zone of whoever created the workspace rather than to UTC. This is the anchor for times that belong to a PLACE — record dates are stored as plain wall-clock, and this says which wall that clock is on. It also fixes two things that had been silently running on UTC for everybody: a scheduled automation set to "every day at 9am" now fires at 9am where you are, and the grid's relative date filters count days against your calendar rather than Greenwich's. Instants — "edited 2 hours ago", when a digest was sent — are a different question and still render in YOUR zone, which is what the per-person setting on your profile has always meant.
Dashboard tiles stopped being pictures of charts and became the same chart engine the report page uses — every series plotted, a real axis, a tooltip. And a bar or a point is now a way in: click one and see the records behind it.
A mark on a chart is now a way into the data, on both reports and dashboards. Where one record is behind it, it opens that record in the peek drawer. Where a group is behind it, it opens the list of that group's records on the same drawer stack — so clicking a row pushes the record on top of it and "← Back" returns you to the list, rather than dead-ending on the first thing you open. The list is paged from the server and its header counts the whole group, not the page. Because the group is resolved by re-running the same grouping rather than by reconstructing a filter, the answer is exact, and it's CURRENT: a bucket that has emptied since the chart was drawn comes back empty and says so. Tiles drill even before you've saved them.
Bar and line tiles now go through the same chart engine as the report page: a proper axis with sensible round numbers, every series plotted, a tooltip that reads all of them at the point you're hovering, and marks you can reach with the keyboard. They were previously assembled as strings — three gridlines drawn at fixed fractions of the box while the points were positioned by different arithmetic, so they sat about six pixels out of true at each end, with the stroke stretched out of shape. The sharpest of it: the bar tile read only the FIRST series and dropped the rest, so a report with four plotted columns rendered on a dashboard as one column and looked complete. The data had been arriving in full the whole time. Tiles adapt the data to the space they're given — fewer ticks, thinner bars, labels thinned rather than overlapped — instead of scrolling.
A dashboard tile measuring a Lookup, Rollup, Formula or Auto number summed it to a confident zero — with the record count beside it perfectly correct, which is what made it so hard to catch. "Total buyer spend: 0" over twelve orders that plainly have values, and nothing to distinguish it from real data. The cause: those fields hold no stored value, since they're worked out per record as the page loads, and the tile was reading stored values only. It now resolves them the same way the report page always has. Two things went with it. A measure that can read nothing now says so and points at the setting, rather than drawing a flat line at zero. And blank cells are skipped rather than counted as 0, so an average is no longer dragged down by records that simply have no value — the KPI tile had always done this, so the same numbers had been answering differently depending on which shape you drew them as.
An inbound address can now file thirteen different parts of a message into whichever fields you choose — including matching the sender to a record and creating them if they're new. And the emails your customers receive are editable, with a live preview, instead of being ours.
Settings → Email templates lets you rewrite the mail RowFold sends on your behalf: form acknowledgements, ticket replies and chat transcripts on the customer side; submission alerts, digests, watched-record changes, mentions and the four approval mails on the member side. Each has a live preview against real sample data, tokens for the record and workspace, and a reset to the original. Two boundaries are deliberate. A customer-facing template may only reference what that surface already publishes, and a member-facing one is resolved against each recipient's own permissions, so a template can never become a way to email someone a field they aren't allowed to see. And RowFold's OWN mail — invites, sign-in links, security alerts — is not editable and never will be: an admin who could rewrite a sign-in email could phish their own team with a genuine, correctly-signed RowFold message.
An Email In address used to fill three fixed slots, two of which had no editor at all — they were guessed when the mailbox was created, so a table with no Email field silently never stored who wrote in, and nothing said so. Mapping is now its own page and a list you build: subject, the message with quoted replies and signatures stripped, the message with all of it, the sender's address, name or domain, who it was sent to, Cc, the received date, any named header, and the attached files. Two do more than copy text. A fixed value writes the same thing on every message — "Source = Email" — so a mailbox can feed a queue that already has conventions. And Match sender to a record links the message to the contact or company it came from, creating them if they're new, so an inbox quietly builds your contact list. The panel at the foot shows what your last real email contained, so you map against a message rather than against a guess.
Five things a workspace needs before it can be where the numbers actually live: states a record must move through legally, units that convert instead of guessing, identifiers people can read down a phone line, links that stop being true when they stop being true, and history that says who really did it.
Setting an AutoNumber field's format was a table-level page called Numbering, reached from a button next to Posting rules and Lifecycle — so the one screen that showed no sign the feature existed was the AutoNumber field itself, which is where anyone looking for it goes first. The format, when the counter restarts, and whether a number is handed out on creation or on reaching a state are now controls on that field's own row in Edit fields, with a live preview of what the next record will get. The Numbering page survives for the one thing a field row can't express — several schemes numbering off a single column, each with its own condition and priority — and the field's row links to it.
A change made by an automation is now recorded as that automation, not as the person who configured the rule months ago — the one way a history actively misleads is by saying somebody was at their desk when nobody was. Every entry also carries what KIND of thing wrote it (a person, an automation, the AI, an import, a public form) as a fact you can filter and count on, kept separate from the label it displays. Bulk operations stamp every row they touch with a single batch reference, so the four thousand rows one import wrote are one identifiable thing rather than four thousand unrelated edits. And history now has a retention setting in Settings — 24 months by default, or keep forever — enforced by the nightly prune. It is a duration rather than a cap on rows on purpose: "the last 500 changes" cannot answer whether a value was different in March.
A relation can now be dated: this employee reported to that manager from January to June, this product sat in that category until the range was renamed. Switch dating on for a field and each link carries a validity period, so a link whose period has ended drops out of lookups, rollups and anything that travels the relationship — without anybody having to remember to unlink it. Periods are half-open — the from is included, the to is not — which is the convention that stops a link belonging to two periods for one day, and it lives in exactly one place so no caller can get it subtly wrong. Overlaps are refused by default, because a record quietly having two parents on the same day is the kind of wrong that only surfaces when a report disagrees with itself; you can soften that to a warning on the relationships where overlap is genuinely real. Turning dating on changes nothing until somebody actually dates something: an undated link is true at every instant. Reporting AS OF a chosen past date is the next step — the resolver already takes the date, nothing asks it for one yet.
A Number field can carry a unit, and a workspace now has a unit library — mass, length, count, volume, time, area, and anything you invent — set up in Settings → Units. Values are stored canonically in the class's base unit and shown in the unit you picked, so a total across rows entered in grams, kilograms and tonnes is simply right. Conversion happens freely inside a class and is REFUSED across one: turning a mass into a length depends entirely on what is being measured, and a silent 1:1 fallback is exactly how a figure ends up wrong by three orders of magnitude with nothing raised. Factors are stored as decimals rather than binary floats, so nobody is ever shown 0.30000000000000004.
A table can now have a state machine: which states exist, which transitions are legal, which fields are required or locked in each one, and whether a record sitting in it may be deleted. The state itself is an ordinary Select field's value, deliberately — that is what makes "everything sitting in Qualified" a board column, a saved view, a filter, a rollup and an automation trigger without a single one of those features needing to learn a new concept. What the state machine adds is the part a Select cannot do: an illegal move is refused rather than recorded. Each state also declares what it MEANS — not started, running, ended well, ended badly — so reporting and anything built later can reason about a state set it has never seen, whether the workspace calls it Issued, Qualified or Under review.
An AutoNumber field can be given a format — WO-{YYYY}-{####} — and hand out identifiers people can read down a phone line. It extends AutoNumber rather than replacing it: a field with no sequence keeps giving out plain integers exactly as before, and because AutoNumber is already server-owned, no write path anywhere will accept a value for one, so nothing new had to be protected. Several sequences can share a field, each with its own condition, priority and counter — that is how purchase orders and sales orders number independently off the same column. Counters reset yearly, monthly or never, and a number can be allocated when the record is CREATED or when it reaches a lifecycle state. The second is the one you want wherever a lifecycle exists: allocating on creation means every abandoned draft burns a number, and a sequence full of holes reads as broken even while it is working correctly.
A saved view can be published as a read-only page for people who will never have a login — and signing up stopped asking for a password at all.
The description you type on the homepage is handed to sign-up and used to draw your first workspace. It was kept in the browser and only ever cleared by a build that ran all the way through — so a sentence typed once and abandoned stayed on that browser indefinitely. Clicking plain "Start free" weeks later and typing nothing was answered with "You said 'I make screws, every different type.'", and two screens on, those same words were what got built. A brief now travels only from the link that carried it, expires as an abandoned funnel after an hour, and is cleared the moment you arrive at sign-up without one. A sentence you typed is quoted back as "You said"; a description you picked off an example card is called "Your brief", because choosing is not the same as saying.
Any saved view can be given an unguessable link that shows it as a read-only page — a supplier's order list, a status board for a client — with no login and no account. The share freezes the columns it was created with rather than following the view: adding a column later must not silently widen a link you handed out months ago. Attachments never render and people cells never print ids, and there is deliberately no anonymous route to an individual record, so nothing on the page is a way in to anything else. Links can be expired or switched off, and every closed link — unknown, disabled, expired, or pointing at a deleted view — shows the same page, because a distinguishable "expired" would confirm the token was once real.
Registration now asks for a team name and an email address and nothing else — no password, no name field, no terms checkbox. A sign-in link arrives in your mailbox, and that link is an ordinary way in rather than a recovery path: single sign-on policy and two-factor are both re-checked after it is spent and before any session exists. Typing an address that already belongs to somebody now sends a sign-in link to that mailbox instead of signing you in as its owner — knowing an invited address plus any password used to be enough to claim the account, and that is the hole this closes.
A field type whose value a model writes from a prompt over the record — a summary of a long thread, a category from a description, a first draft of a reply. The result is stored text, so it filters, sorts, groups and exports like any other column, and it can tell your correction from its own work.
A new field type whose value a model produces from a prompt over the record — a one-line summary of a long thread, a category from a description, a first draft of a reply. What makes it a field rather than a chat answer is that the result is STORED text: it filters, sorts, groups, exports and imports exactly like Text, because text is what sits in the record. Two things it deliberately does not do. It never generates on read — a grid of 500 rows would be 500 calls just to scroll past — so generating is always an explicit act: the ✦ in the cell for one, the bulk bar for a selection, with a dry run that tells you what a batch will cost before anything is spent. And it knows its own work from yours: it stores a hash of what it generated, so a bulk regenerate skips the cell you fixed by hand instead of overwriting it. The prompt uses the same {{record.*}} vocabulary as automations, so a Relation reaches the model as the linked record's name rather than a list of ids.
Choose the payload shape, filter which changes are worth sending, add the headers the far end demands, and re-send a delivery that failed.
Four things the far end usually dictates, now yours to set. Payload shape: full — the record's values, its display layer and its previous state — or minimal, for a receiver that only needs the id and will fetch the rest itself. Filters, so a hook fires on the changes that matter rather than on every save. Custom headers, for the endpoint that wants an API key alongside the signature. And redelivery: a failed delivery can be re-sent from the deliveries list once the receiver is fixed, instead of being lost. Posting and unposting stay their own events rather than updates, because a receiver that only cares about "official now" should not have to diff every ordinary edit to find it.
The filter, search and share bar that only the grid had is now the same control on Calendar, Timeline, Tree and Map — and a view that cannot run a filter says so, instead of quietly showing you nothing.
The grid compiles filters to SQL. Calendar, Timeline, Tree and the map scan a capped set of rows in memory, and cannot traverse a link or read a computed field. Those two kinds of term used to fail in opposite directions and both silently: a term crossing a link was waved through and filtered nothing at all, while a term on a Lookup, Rollup, Formula or AutoNumber matched no row and emptied the view — so a saved "Open tasks > 0" turned a 75-event calendar into an empty one with no explanation. Both are now dropped rather than misapplied, the filter menu stops offering them on those surfaces, and the toolbar says how many filters don't apply here, with a link to the grid, where they do.
Filter, search, sort and share used to be a grid feature. Calendar, Timeline, Tree and Map now render the same control, resolved by the same code, so the filter and sort popovers are literally the same thing in all five places. Before this, Calendar and Gantt quietly honoured a saved filter no user could author, and Tree ignored filters altogether — three behaviours from three copies of "apply the view". Navigation keeps the filter too: stepping to next month, switching calendar mode or changing the Gantt zoom no longer throws away the filter the toolbar is still drawing chips for.
Comments with mentions on any record — or on the table, when the question is about the data as a whole — a per-record activity feed, and columns you can pin while the rest scrolls.
An internal discussion thread on any record, kept deliberately separate from the customer-facing conversation on mailbox- and widget-connected tables, so a note to a colleague can never be mistaken for a reply to the customer. Mentioning someone with @ notifies them and adds the record to what they watch; the mention is resolved against the workspace's membership when it is posted, so a name pasted for somebody who is not a member notifies nobody rather than silently pointing at a stranger. A thread can also hang off the TABLE rather than a row, because "where are all the US orders?" is a question about Orders however you happen to be looking at it — and a thread on somebody's personal view would be a conversation nobody else could reach.
A grid can freeze its leftmost columns so they stay put while the rest scrolls sideways, set from the column menu. It reads "Freeze through <column>" because freezing is a boundary rather than a per-column flag: a column pinned to the left edge while the four before it scrolled would simply land on top of them, so any column can be the boundary and everything to its left comes with it. Nothing pins automatically. The boundary is counted over the columns as the view actually renders them, so hiding or reordering moves it with the layout instead of stranding it, and the checkbox and row number are chrome that were always pinned anyway. On a phone the data columns unpin and the chrome stays.
Every record now keeps its own history — who changed which field, from what, to what, and when — written centrally at the point every save already passes through, so the grid, the peek drawer, an import, an automation and the public API all produce it with nothing wired up per surface. It is the record-scoped sibling of the audit log rather than a replacement: the audit log is the workspace's forensic trail, this is the story of one row. Field keys are resolved to names and ids to record and person names when you READ the feed, because names change and the history should say what things are called now.
Lookups and rollups can now filter which far-end records they include — "sum of Amount where Stage is Won" is one field, and the conditions work however deep the route travels.
A Formula or a Rollup can now say how it should be presented, with a Show as setting on the field: Number, Currency, Percent, Progress or Duration, plus decimal places where they apply. Until now formatting was carried by the field type — Currency showed money, Progress drew a bar — and a field has exactly one type, which a calculated field had already spent saying it was calculated. So a line total of {Qty} * {Unit Price} printed 1234.5 beside a Currency column printing £1,234.50, and a rollup summing that same currency column lost the formatting crossing the link. It changes the display only: the underlying number is untouched, so filters, sorting and totals still work on the real value. The format follows the value into the grid, the peek drawer, the record page, reports and their CSV and PDF exports, generated documents, dashboard tiles and CSV exports. Lookup fields deliberately have no Show as — a lookup re-presents a field that already carries its own type, and letting the copy restate the formatting is how the two drift apart.
A rollup's "only include records where…" can now test a field one link past the records it is filtering — shown in the dropdown as Order → Type. This is what lets the thing that distinguishes a purchase from a sale live on the order, where it belongs, instead of being copied onto every line to make the filter legal. A product can now total "Quantity across Order Lines, only where Order → Type is Purchase", pair it with the same rollup for sales and a formula subtracting the two, and stock on hand keeps itself right beside a reorder level — no automation, no stored counter, nothing to drift. One limitation for now: filtering or sorting the grid BY a rollup that uses a routed condition is skipped rather than approximated, so the column shows the right number but does not yet filter.
Every Lookup and Rollup can now say which far-end records it includes: "Only include records where… Stage is Won", with conditions picked from the far-end table's real fields and the same operators grid and report filters use. "Sum of Amount across Deals where Stage is Won" is one field now — and unlike the single-hop conditions other tools offer, these work however many relationships deep the route travels. Reports that follow relation paths get the same filtering for free, since both run on the same resolver.
Compute a value from an expression over a record — with functions for text, math, dates and logic, and the one thing other tools make you build a separate field for first: reaching straight through a link.
An order total can now sum a calculated line total. Formula fields appear in the list of things a Rollup can aggregate, so the arithmetic each line already does — quantity × unit price, less its discount, converted at the order's rate — is the thing the parent totals, with no duplicate stored column to keep in step. What the formula is built from does not matter: it can reach through a link, or read the line's own Lookup and Rollup fields, and it is evaluated on the line exactly as it is in the line's own cell. The only formula a rollup will not take is one that does not currently compile — there is nothing to total in an expression that does not mean anything yet.
{Company.Region} follows the Company relation field and reads Region off the linked record directly - no Lookup field has to exist first, and it chains as many hops deep as the schema allows ({Company.Region.Manager}). Combine it with an existing Rollup field by referencing it by name for totals across a to-many relation. The route is resolved the same way a multi-hop Lookup is, batched across the whole page rather than one query per record.
A new field type computes its value from an expression instead of storing one — {Amount} * {Probability} / 100, IF(...), ROUND(...), DATEDIF(...), and around forty other functions across text, math, dates and logic. Reference any field on the record by name in curly braces, and unlike a Lookup or Rollup, edit the expression any time without deleting and recreating the field. Formulas are checked as you type: an unknown field name gets an immediate "did you mean" suggestion, and a problem is reported at the exact spot in the expression rather than a generic error.
The formula box now completes as you type — { opens field suggestions that walk through links with dots, and function names complete with their signatures. Or skip the syntax entirely: describe what you want in plain English and press Write it for me. The generated formula is compiled against your real schema before it reaches the box, so the AI can never hand you an expression that doesn't validate; if its first try doesn't compile, it sees the exact error and corrects itself before you see anything.
Two things a security page should never have to be vague about. Every browser signed in to your account is now listed, and endable one at a time. And an owner can require their team to sign in through Google or Microsoft rather than a password — refused at the form, enforced on sessions that were already open, and held back until nobody would be locked out by it.
Settings → Security now lists every browser currently signed in to your account — browser and operating system, how it signed in, where from, and when it was last active — with the one you are reading from marked. Any other row can be signed out on its own, or all of them at once while you stay put. Sign out everywhere is still there for the day you think someone else has access. The list is the whole point, so it is complete by construction: a session that cannot appear in it cannot reach the app either.
Connected accounts on Settings → Security links a provider to the account you are already signed in to. This is the surface the sign-in page has always pointed at when it refused a provider that would not vouch for your email address — RowFold matches on the provider's own account id, never on the address, so linking from inside a signed-in session was the missing way for that identity to safely reach the account. Disconnecting is refused whenever it would leave you with no way back in.
A workspace owner can require everyone in the workspaces they own to sign in with Google or Microsoft instead of a RowFold password, so joiners and leavers are handled where the directory already handles them. Passwords are refused at the sign-in form, and anyone already signed in with one is asked to switch rather than left running for the rest of their 30 days. The switch stays unavailable until it is safe: it names anyone on the team who has not connected a provider yet, and waits for them — because unlike two-factor, this is not something everyone can comply with on the spot.
Approvals that end in something. Records earn their way to Posted through real stages — quorums, gates on the linked records, clocks with teeth — and Posted means sealed: read-only in the app, imports, automations and the API alike, until someone unposts it with a reason, on the record.
Two new triggers — a record is posted, a record is unposted — and a new step: Request approval, asking a fixed person or whoever a People field names, with an optional note, due window and Select mapping. Later steps can use {{approval.approver}}, {{approval.url}}, {{approval.dueAt}}, {{approval.note}} and {{approval.record}}, so a follow-up email can carry the decide link itself. The public API reads a record's approval trail, raises asks, and posts or unposts records (refused when the policy says admins only); postedAt and postedBy ride on every record payload. There is deliberately no machine decide endpoint — "who approved this" must always be a person.
Each stage can carry a due window, a reminder cadence (in-app, and email for people whose own toggles allow it), and a delay before it opens — give Legal a day with the contract before Finance is pinged at all. When an ask blows past due, the stage's escalation runs: notify, add an approver, reassign with a visible "for {name}" trail, or auto-approve / auto-reject — and an auto-outcome always writes an explanatory note, so there are no silent robot decisions in the trail. Anyone can set a delegate and an until-date in Settings; new asks redirect to the delegate with the trail showing, and the redirect simply stops applying when the date passes.
Asks land in the new Approvals queue (Waiting on you / You asked / Done, with j, k, A, R and O doing the work), as Approve/Decline buttons right in the notification bell, on the record's own Posting panel — and in the email, where Review & approve opens a signed confirmation page that needs no login: being asked is the authorization. Opening the link never decides anything; only the press on that page does, because corporate security scanners follow every URL in every email and a robot must not be able to answer for you. Links expire after 14 days. Declining always requires a reason — it matters most when the answer is no.
A posting policy can require things of the records on the other end of a relation before the seal goes on: every linked line item Approved, the linked purchase order itself Posted. Gates travel the same routes lookups and rollups do, their verdicts sit on the record's Posting panel while people wait, and they re-check at the moment of posting so nothing slips through on a stale reading. An "every linked…" gate deliberately blocks a record with nothing linked at all — a childless invoice is a blocked invoice, not a vacuously postable one — unless the policy says empty is fine.
Posting stamps a record — when, by whom — and from that moment every write path refuses it: the grid, the record page, the drawer, bulk edits, imports, automation steps, and the API (a clean 409, never a surprise). Attachments and generated documents are deliberately still allowed — the signed PDF of a posted invoice is a note pinned to the seal, not the sealed content — and deleting a posted record is refused outright: the seal outranks the bin. Unposting is the audited escape hatch: delete-level access, a written reason, and both on the record for good. A policy can also name relation fields whose linked records post and unpost together with the parent, and a date field unlocks Lock period — post everything dated on or before a chosen day, in one action.
Any table can now carry posting rules: ordered approval stages, each naming its approvers (picked people, a People field on the record, or a role), its quorum (everyone, any one, or N of M), and conditions that pull it into the journey only when they match — the CFO stage exists when the amount says so. Submitting opens stage one; a met quorum advances the record that instant, in the same transaction; the next stage's people aren't asked until it does, so nobody sees an ask that might not matter. The whole journey is written through a real Select field — "Approval status" is created for you if you don't pick one — so every stage of it is a saved view, a board column, a report group and an automation trigger for free.
Select chips now colour themselves by meaning everywhere they render: Approved, Done and their kin go mint; Rejected and Changes requested go coral; Pending, In review and every "Awaiting …" value go amber; and Posted wears the dark seal. A board of records mid-journey reads at a glance, whether or not a posting policy wrote the values.
While a policy protects its approval status field, that Select only changes through the flow itself — hand edits, bulk edits, imports, automations and API writes are all refused, each with a named reason in its own surface. An "Approved" in that column therefore always means a real decision by a real person, which closes the hole most tools leave open: an approval workflow whose result is an ordinary cell anyone can flip afterwards. Everything that reads the field is untouched, and the flow's own writes fire automations and webhooks like any other edit.
Trust as receipts, not promises: AI changes signed in the audit log under the AI's own name, one-click undo, a verification tally that publishes its misses, and a readable list of what the AI can't see for you.
Everything the AI creates or changes now appears in the audit log as its own actor — "AI · Ask (for you)" or "AI · Build (for you)" — exactly like "API · token" and "Automation · name", so an AI write is never dressed up as a human one. Records the AI creates get an Undo button right on the confirmation: one click moves the batch to the Trash, restorable like anything else.
The Ask page now shows how many numeric claims were re-checked against your live data this month, how many held, and how many didn't (the answers said so at the time). A counter that can only report success is marketing; this one is evidence. Alongside it, a new panel lists the exact fields hidden from the AI for you, by name — the permissions guarantee made readable instead of asserted. The whole trust surface is documented publicly at /ai-trust.
Every automation can now have its own inbound URL: point any outside system at it and a JSON post becomes a trigger, with the payload on tap in every step.
A new trigger: a webhook is received. Saving the automation mints an unguessable inbound URL; any system that can send a webhook — a form tool, a payment provider, Zapier, your own code — POSTs JSON to it and the automation fires. The payload is available to every step as {{webhook.path}} tokens (nested values use dots, array items use numbers), conditions can check payload paths with the usual operators, and a post that doesn't match is logged as a Skipped run so "why didn't it fire?" stays answerable. The receiver answers 202 immediately and the steps run in the background.
One picker everywhere a record gets linked, searching the whole table instead of a slice of it — and the peek drawer stopped being somewhere you can only look.
The grid cell, the record page, the new-record form, subitem rows and the peek drawer now share a single link picker. It searches the whole related table on the server rather than a slice of it, loads more as you scroll, takes the keyboard, shows every current link as a chip you can remove, and lets you type a name that doesn't exist yet and create it on the spot. It also respects how the field was set up: a relation that holds just one record replaces as you pick, one that holds several accumulates.
Following a link from inside the drawer lays a new sheet over the last one, leaving a sliver of the one beneath showing down the left edge - click that sliver to go back to it. The top sheet keeps its full width however deep you go; sheets used to be laid side by side and shrink until the oldest slid off the screen. Anything you were half-way through typing on a lower sheet is still there when you return.
Relation fields on the record page and the new-record form used to be a list of the 200 most recently updated records. A link pointing at anything outside that window had nothing to post back, and saving the record treated its absence as removal - so editing an unrelated field could drop links without a word. The list was sorted alphabetically after being cut, which made it look complete. The picker now works from the record's own stored links, so it cannot write back fewer than it was given.
Click any value in the drawer and it becomes an editor in place, saving as you leave the field. Relations open the same link picker as everywhere else - previously they were the one field type the drawer would show you but never let you change, which meant opening the full page for the most connected thing in the product. Computed fields (lookups, rollups, auto-numbers) stay read-only, and attachments, subitems and documents are still full-page work.
The support widget stops pretending someone is sitting there. It says when you'll reply, shows the customer where their ticket has got to, and lets you watch the whole thing before you ship it.
The Widget view now carries the real chat window - same markup, same stylesheet, your branding - and plays the whole round trip when you type into it. It runs on a scripted conversation rather than the live endpoint, so designing a widget never files a real ticket into your own table.
Received the moment it lands, then whatever your team's own Select field says - published per option, in your words. "In progress" can read "Working on it"; "Tier 2" can read "Escalating to a specialist". Moving the card is telling the customer. Options you leave blank are never shown, so internal states stay internal.
An expected reply time, chosen per widget and shown in the header before they type a word. Say "a few hours" and keep it, rather than leaving someone to guess whether anyone is coming.
Three bouncing dots appeared for two and a half seconds after every message, whether or not anybody was there - a live-chat affordance on an async product, and the fastest way to make a good reply time feel like a broken one. Replaced with where the message went, when to expect an answer, and real progress.
Ask stops asking to be believed. Every figure is re-run against your live data and the receipt is one click away — the query that ran, and what it returned.
The opening suggestions are written from your real schema - your table names, your fields, your relationships - instead of four generic examples about a "status" field your workspace may not have.
Ask names the aggregate rather than supplying the numbers, and RowFold re-runs it and plots what comes back - so the picture cannot drift from your data even if the sentence above it does.
Rather than silently picking one, it answers the likely reading in full and offers the other as a one-click chip.
Questions are set as headings and answers as body copy, with the evidence beneath - a research note rather than a chat log. The /Ask page is now the generous version, with the list of what RowFold can see beside the composer instead of buried under it.
Answers used to be a dead end unless they happened to be an aggregate worth saving as a report. Copy any answer, or share a link to the whole conversation - it opens for a colleague under their own permissions, never yours.
Bars shared a column with their labels, so every bar asked for more room than was left and flex-shrink clamped them all to the same height - 16, 15, 14 and 13 drew identical. Bars now measure against their own track, and the scale starts at zero.
Models reliably link the record an answer is about and just as reliably leave the supporting ones as flat text. RowFold now re-links those itself, using only ids it saw in real tool results, so a list of four pets is four records you can open rather than one link and three dead names.
Past conversations show when they happened, can be searched by what you asked, and can be removed.
Answers have re-checked their own figures for a while; now you can see how. Click the badge and RowFold shows every claim it re-ran, the exact query it replayed against your live data, and the real result that came back. It opens inside the conversation, so nothing you were reading is lost.
The chips that narrate an answer as it works - Crunching numbers in Visits, Opening a record - now open. Each shows the query that ran and the data it returned, so the working is inspectable rather than decorative.
A prose answer with no figures in it now says so, instead of showing nothing and leaving you to guess. An answer with a figure that did not re-confirm names how many, and the receipt says which.
Type something that reads like a question into search and the palette stops offering record matches as the answer: Ask moves to the top and Enter asks it. Finish with a question mark and it hands straight over, carrying your text.
Every ticket keeps its whole conversation — theirs, yours, and the notes they never see — in one ordered thread on the record.
Add a Chat widget view to any table, paste one line on your site, and a visitor's question becomes a ticket — the same front door as forms and email-in, filing into the same conversation thread your team already answers from. Replies reach them in the chat, and by email too if they leave an address. The chat runs inside a frame served by RowFold, so the site hosting it can never read what your customers type. Ending a conversation clears it from that browser, with the transcript emailed first if they want a copy.
Every message you send carries a reply address unique to that one record, so a customer pressing Reply lands their answer on the right ticket even when their mail client strips the threading headers — and plenty of them do. Where that address is missing we fall back to matching In-Reply-To and then the References chain. We deliberately never match on subject: “Re: Invoice” from two different customers is exactly how support tools end up showing one person another's conversation.
A table with an email-in address now shows a Conversation on every record: what the customer wrote, what you wrote back, and internal notes they never see, in one ordered thread. Reply from inside the record and it goes out as an email — their answer comes back into the same thread instead of arriving as a second ticket nobody connects to the first. A reply that fails to send says so on the thread rather than quietly looking answered, because the only thing worse than a missed email is a second person sending the same one.
The pages your customers actually see now belong to you — your logo, your colour, your typeface, and our badge only if you want it.
Branding is account-level on purpose — one company, one look, however many workspaces — but a single form can still differ where it plausibly should. Give one its own accent for a campaign, hide the logo, or send people to a page on your own site after they submit instead of showing the confirmation card. Everything you don't override inherits, so there is still one place to change your colour and it changes everywhere.
Settings → Branding dresses your public surfaces in your identity instead of ours: a logo, an accent colour, a page background, one of four typefaces, and the organisation name that signs your emails. Pick any accent — the hover shade and tint are worked out from it, and the button label flips between black and white so it stays legible whatever you choose. The “Made with RowFold” badge can simply be switched off, on every plan including the free one. And nothing on those pages loads a web font, so a form filled in by your customer talks to nobody but you.
A form is a view of a table like any other: designed by dragging, able to take files, and wired to tell someone it arrived.
A form now names who hears about it. Pick the people who work the queue and they get a RowFold notification — plus an email if their own settings say so — and add an address outside RowFold entirely for a shared support@ inbox. Those people are put on the new record's watch list by default, so they hear about the reply and the status change too, not just the arrival. And if the form asks for the visitor's email address, you can send them an acknowledgement in your own branding, with a copy of what they filled in.
Put an Attachment field on a form and the people filling it in can upload — a CV with the application, a photo with the claim, a receipt with the expense — with no account and no chasing them for it afterwards. Files arrive on the record as real attachments the moment it is created, identical to anything uploaded inside RowFold. The browser never gets to state what a file is called or how big it is; every detail is read back from our side at submit, and anything picked but never submitted is cleaned up within hours.
Forms were easy to build and easy to lose — a separate page you had to remember existed. A form is now a view type: add one from the view switcher and it sits beside Grid, Board and Calendar, because how work gets in belongs next to how you look at it. The builder came with it — drag questions in from the field list, drag them around to reorder, click one to set its wording, help text, whether it's required, and the earlier answer that has to match before it's asked at all — with a live preview of the page a visitor will actually see. Old links keep working, and a form built before any of this quietly gains its tab on the way through.
One account, one workspace, everything relatable — organised by folders that carry access without cutting a single relationship.
Give someone a whole folder in one action instead of granting table by table. “The contractor gets the Acme folder” is now a single setting, and every table inside inherits it. A table’s own override still wins, so a deliberate per-table decision is never quietly overruled by a broader one.
Tables now live in folders: “Sales”, “Ops”, one per client. Crucially a folder is not a wall — a table in one folder relates to a table in another exactly as before, which is the whole reason folders replaced separate workspaces. Folders stay invisible until you have more than one, so a fresh account sees a plain list of tables and nothing else.
Adding a template or describing a new operation to the AI are the same act by different routes, so they now behave the same way: each build lands in one folder named after itself, alongside — and relatable to — everything you already have. Your second build no longer scatters its tables through your first.
Setting up no longer holds you on a spinner. The workspace is yours immediately and the tables, sample data, reports and dashboard build behind you — with a live panel naming each table, link and report as it lands. Browse your records the whole time; nothing is locked.
Self-serve subscriptions, live notifications and the tidying a workspace needs once it carries real load.
When a teammate changes data, whatever you're looking at updates in place: rows appear in grids, pins move on maps, bars slide on timelines, report charts redraw, dashboard widgets re-pull their numbers, and a record's related list stays current — always through your own permissions, never with a page reload. Even structure travels live: a new field grows a column in every open grid (instantly editable), a new table appears in everyone's sidebar, and a saved report or re-arranged dashboard takes its new shape for all viewers. Bursts like imports coalesce into a single quiet update, changes to tables you're not viewing stay out of your way, and if you're mid-edit the update politely waits.
One click, no password: Google sign-in on both the sign-in and sign-up pages. If you already have a RowFold account for that email you land straight in it — no duplicates, your password keeps working too — and brand-new signups go through the normal onboarding. RowFold only trusts addresses Google itself has verified.
Watch any record and every change lands in the new notification bell — optionally your inbox too. You're notified when you're added to a workspace and when an automation fails. And grids now update live: when a teammate edits a record you're viewing, it refreshes in place within a moment, always through your own permissions.
Tables now organize into collapsible sidebar groups — one per client, department, or topic. Templates you add create their own group automatically, and each group remembers whether you keep it open or closed.
The Team plan is now self-serve: subscribe from Settings → Plan & billing (or straight from the trial-ended page), with secure checkout and receipts by Stripe. One subscription covers everyone in the workspaces you own - seats count only people who can edit, Viewers stay free forever, and the count adjusts itself with fair proration when your team grows or shrinks. Manage your card, switch monthly ↔ yearly, download invoices, or cancel any time from the same place.
Forms, email and files — three ways for work to arrive in a table without anyone opening RowFold.
A new field type for files — contracts, photos, CVs — up to 10 files of 10 MB each per field, stored privately with downloads gated by the same permissions as everything else. The grid shows a compact file count; upload and manage from the record page.
Create a mailbox address for any table and every email sent to it becomes a record — subject as the name, sender and body mapped into your fields. Forward your support address at it and your help desk runs on RowFold: numbered tickets, automations announcing new ones, views for the queue, and AI to summarize what people are asking.
Email-in now stores attachments: map an Attachment field on a mailbox (the Files column) and every file on an inbound email is saved to the record exactly like a UI upload — same limits, same private storage, executables refused, signature images ignored. An emailed CV arrives ready to preview. And finding your table's address is now one click: the ✉ Email-in button sits right next to + New record.
Every table can now publish forms: a shareable link anyone can fill without an account, with drag-to-reorder questions, per-field required flags and help text, and conditional questions that only appear when an earlier answer matches. Submissions become records instantly — auto numbers stamp themselves, automations fire, and you can have each submission emailed to you. Rate limiting and a bot trap are built in.
Addresses that complete themselves, and every table one click away from being a map.
A new Address field type suggests real addresses as you type — in the grid, on the record page, in the peek drawer, and on public forms — so what gets saved is a clean, complete address instead of a guess. It behaves like text everywhere else: filter it, report on it, import into it, or convert an existing Text field over losslessly.
Every table can now be a map. Add an Address field, flip to the new Map view, and each record becomes a pin — clustered where they crowd, one click from the record itself. Locations are looked up once and remembered forever, filters narrow the pins like they narrow the grid, and a status pill keeps count while a big table fills in.
Reports that arrive already made, and records that number themselves.
Signing up is smoother: templates chosen on the website carry through to the setup wizard, onboarding workspaces arrive with the same rich sample data as the gallery, a gentle banner asks you to confirm your email so password recovery always works (SSO accounts skip it — they're already verified), and SSO sign-ups get the welcome email too. In the app, the three mystery icons in the bottom-left corner are now a labeled account menu — Trash (recover deleted records), Settings, Security, and Sign out.
Invoices, orders, and tickets can now number themselves. Add an Auto number field, pick the starting number, and every record gets the next one automatically — whether it was typed in the grid, imported, or created by an automation, the API, a connector, or the AI. Existing records are numbered oldest-first when you add the field, numbers are permanent and read-only, and imports that carry their own numbers keep them.
Creating a report now starts you with a real one: RowFold reads the table and seeds the right grouping (Select fields, or Dates bucketed by month), a genuine sum aggregation so KPI cards and totals populate, and the chart type to match. Switching the base table re-seeds smart defaults instead of emptying the canvas. Aggregations can now target the report's own rows (total revenue, average deal, record counts) as well as related tables. And the fastest path of all: tell Ask “revenue by month as a report” and confirm the card — or press Save as report on any AI answer that ran the numbers, or promote a dashboard metric tile to a full report page.
Ask stopped being a search box and became a builder — with your approval on every step.
Tell Ask “send me a weekly digest” and a short AI summary of what changed lands on your Home page every Monday — or each morning, if you choose daily. It is built only from data you can see, and when email delivery is configured a copy arrives in your inbox too. Turn it off any time from the card.
When an answer contains totals or counts, RowFold re-runs the queries behind them after the answer is written — ✓ numbers verified means everything re-computed cleanly against your live data. Answers are better grounded, too: the AI sees your fields’ real values and ranges, sample records, and saved views, so filters land right the first time. And within a conversation it remembers what it already looked up, so follow-ups come back instantly instead of re-querying.
The Ask chat has grown from answering questions to building alongside you. Describe what you want — connected tables, a batch of related records, a saved view, a dashboard, an automation, even inventory that tracks itself through rollup fields — and Ask proposes it on a card showing exactly what will be created. Nothing exists until you press the button. Multi-step work flows on its own: confirm the schema and the records follow; confirm one batch and the next appears. When something genuinely needs your call, Ask asks a quick question instead of guessing. Automation drafts arrive switched off for review, and the old Build with AI form now opens this conversation.
No more waiting for the AI to finish before typing. Enter queues your next message, Ctrl/⌘+Enter interrupts and steers mid-answer, the send button doubles as a stop button, and scrolling up to reread no longer drags you back down — a Jump to latest pill appears instead.
Ask questions about your data in plain language and get answers that cite the exact records they're based on. AI also suggests fields for new tables, designs whole schemas from a description, and helps you import spreadsheets — and every AI feature falls back gracefully when it isn't configured.
Records inside records, maths inside automations, and imports that land where you meant them to.
Importing no longer always means new tables. Point a sheet at a table you already have, map its columns to existing fields (matched up for you), and nominate a column to match on so a re-import updates rows instead of duplicating them — blank cells never overwrite what's there. Several files with identical columns are now combined into one table instead of becoming one table each, which is what you want when an export arrives split by year or region. Large imports also no longer hit a size limit.
An Update step can now follow a relation and write to the linked record, and set / increase / decrease a number by an amount like {{record.qty}}. So “when a dispatch is created, take the dispatched quantity off that part's stock” is a rule you can build in the automation editor. The arithmetic is done by the database in one operation, so simultaneous runs can't overwrite each other's totals, and an optional guard fails the step rather than writing negative stock.
Records that only exist inside another record — the line items on an order, the serial numbers on a line item — can now be created and edited right there, in an editable grid on the parent, instead of being made separately and linked up after. Mark a table as subitems from the parent's field editor, nest as deep as the work really nests, and let rollups total them. Delete a parent and its subitems go with it; restore it and they come back. Build with AI marks the hierarchy for you on new schemas, and Suggest hierarchy on the Schema page finds it in workspaces you've already built.
The workspace learned to act on its own — and to be driven from outside.
The developer docs now include a full reference for every endpoint, with copy-ready cURL, JavaScript, and Python samples — and a built-in console. Paste a token and run any request against your own workspace right from the page. Find it on the Developers page under "API documentation".
Compose your workspace data into a dashboard: KPI cards, line, bar and donut charts, tables, an AI summary, and an activity feed, arranged on a drag-and-drop grid. Point a widget at a saved report or build a metric on the spot, narrow everything by date range, and let Claude lay out a whole board from a single sentence. Then share a dashboard with your team — or make it everyone's workspace home. Look for Dashboards in the sidebar.
Our public docs and the in-app Help Center now draw from a single source, so they can never drift apart. That means everything — including Automations and the API — is documented in one place, always current. Press F1 anywhere in the app for help about the page you're on.
Connect RowFold to everything else. Workspace admins can mint secure API tokens to read and write records, tables, and fields over HTTPS, and subscribe webhooks that push every record change to your systems the moment it happens — signed, retried, and logged. It's all on the new Developers page.
Set up rules that watch your data and act on it: when a record is created, updated, deleted, enters a state you care about, or on a schedule, RowFold can update fields, create records, send an email, call a webhook, or generate text with AI. Every run is logged so you can always see what happened and why. Look for Automations in the sidebar.
A free trial, a help centre and a calmer interface — the groundwork for letting strangers in.
We refreshed the whole app around a single, light sidebar — no more switching between modes. Everything you build, connect, and govern lives in one place, a click away, so the workspace is easier to move through.
New accounts start a 14-day trial with every feature unlocked — no card required — and a short guided tour points out the essentials on your first visit. Onboarding walks you from sign-up to your first workspace in three steps.
Every part of RowFold is now documented — every view, field type, keyboard shortcut, and permission rule — searchable at /Help, with an F1 drawer that shows help about wherever you are in the app.
Sign-in, onboarding and the fastest possible edit — the difference between a demo and something you log into on Monday.
Edit in the grid, the way you would expect to. Click a cell, type, move on — no dialog, no trip out to a detail page. Every field type edits in place with the right control for it.
A lightweight record endpoint behind the grid means opening a record no longer reloads the page — and the layout and stylesheet were rebuilt around the denser grid while we were in there.
Registration, sign-in and sign-out, with passwords properly hashed, plus a members list so you can see who is in your workspace. New accounts land in a guided onboarding flow that sets up their first workspace instead of dropping them on an empty screen.
Asking a workspace a question in English, and getting an answer computed from the actual records.
Ask got substantially better at questions that span more than one table: it now follows the links between them to reach the data a question implies, instead of only seeing the table in front of it.
An early workflow engine landed — describe a condition and an action, and let the workspace handle the repetitive part. It grew into full Automations in July.
Ask in plain English and get an answer computed from your actual records rather than guessed. RowFold reads the shape of your workspace, works out which tables and links the question touches, and queries them.
What a real team needs before a workspace can hold real work: other people, other views, and a way in.
Some records are made of other records — an order and its lines, a build and its parts. Composition makes that a first-class relationship instead of a second table you have to remember to filter every time you look at it.
The template library grew to 24 ready-made workspaces spanning sales, projects, inventory, people and operations — and the whole product was reskinned around a calmer, denser visual language at the same time.
The same records, seen the way the work actually runs. Anything with a date shows on a calendar, anything with a parent shows as a tree, anything with a start and an end shows on a Gantt. Switching view never means copying data into another tool.
Bring what you already have. Upload a CSV, map its columns onto fields, and RowFold creates the records — so moving off a spreadsheet is a few minutes' work rather than an afternoon of copy and paste.
Workspaces became multiplayer. Invite people, give them roles, and control what each one can see and change — down to the individual field. Every edit is written to an audit trail recording who changed what, from what, to what, so “who moved this?” always has an answer.
Group, filter and aggregate across a table, then draw the result. Reports save and reload with their configuration intact, so a number you need every week becomes a link rather than a rebuild.
The core idea standing up — tables that know about each other, and a workspace you can actually navigate.
Linking two tables stopped being a special case and became a field type. Point a Relation field at another table and you get a real, navigable link — pick records from a searchable list, follow the link from either side, and let lookups and rollups pull values across it. This is the piece the rest of the product is built on.
Starting from nothing is the hardest part, so we stopped asking you to. Templates open with their tables already linked to each other — not one flat sheet, but a working relational model you can explore and bend to your own process.
Three things that make a large workspace navigable: a schema graph that draws your tables and the links between them so you can see the shape of your data at a glance, a command palette that jumps to any table, record or view without touching the mouse, and a dark mode that holds up for a full day's work.
RowFold's first working shape: workspaces that hold tables, tables that hold records, and a guided builder that walks you from a blank page to a working structure without needing to know what a schema is. Say what you're tracking, answer a few questions, and the tables, fields and links are laid out for you.
Nothing matches that filter — .
Things we're actively working toward. Plans shift as we learn, but this is where our heads are — and why.
Want to nudge something up the list? Tell us what you're building.