Building
Spreadsheet to app in 2026: AppSheet vs Glide vs Softr vs a custom build, and how to move your data
How to turn a spreadsheet into an app: AppSheet, Glide, Softr, Apps Script or custom, what each costs in 2026, Google Sheets’ limits, and the SQL to migrate.
In short
Turn a spreadsheet into an app when several people edit it, people need to see only their own rows, the data drifts, or other tools depend on it. There are five routes: Google Sheets with Apps Script; an app on top of the sheet with AppSheet ($5–$20 per user a month, Core included in most paid Workspace plans) or Glide; a portal such as Softr ($19–$329 a month billed yearly); Airtable, Retool or Power Apps; or a custom app on Postgres. Whichever you choose, split the sheet into tables with one fact in one place, import it through validation rules with a reject pile, and enforce permissions in the database, because Google says protected ranges “shouldn’t be used as a security measure” and anyone who can view a sheet can copy it. Keep the spreadsheet afterwards as a read-only report.
Key takeaways
- Move when the sheet is the system: shared editing, per-person permissions, drifting data or tools that depend on it.
- Size is rarely the limit; Sheets now holds 20 million cells. Permissions and concurrency are.
- AppSheet and Glide are fastest on top of a sheet; Softr suits customer logins; a custom app suits per-person rules and audit trails.
- Split the sheet into tables, import through validation rules, and send rejected rows back to a person.
- Put permissions in the database: a shared sheet can’t hide one row from someone who can view it.
- Keep the spreadsheet as a nightly read-only report, not as the source of truth.
When should a spreadsheet become an app?
A spreadsheet is the right first tool for almost every process. It stops being right when the sheet has become the system the business runs on, and the signs are consistent:
- People overwrite each other. Two people edit the same rows, and the last save wins.
- Everyone sees everything. You need staff to see only their own jobs, or customers to see only their own orders, and a shared sheet can’t do that.
- The data drifts. “Done”, “done ”, “Completed” and “DONE” in one status column; three date formats in another.
- Work happens away from a desk. Field staff need a phone screen with three buttons, not a grid with forty columns.
- You need a trail. Who changed the price, when, and from what, for every row.
- Other tools need the data. Invoices, reminders and reports depend on the sheet, and a renamed column breaks them all.
What are Google Sheets’ real limits?
Size is rarely what forces the move. Google raised Sheets to 20 million cells or 100MB per spreadsheet in September 2026, and Excel holds 1,048,576 rows by 16,384 columns per sheet. The limits that bite are the ones around the data.
| Limit | Figure | Source |
|---|---|---|
| Sheets API reads or writes | 300 a minute per project, 60 a minute per user | Sheets API limits |
| Sheets API request timeout | 180 seconds | Sheets API limits |
| Apps Script run time | 6 minutes per execution | Apps Script quotas |
| Apps Script triggers, total run time | 90 minutes a day on a free account, 6 hours on Workspace | Apps Script quotas |
| AppSheet on a Google Sheet | No more than 100,000 rows or 1,000 columns, and 5–10MB of compressed data per app | AppSheet help |
Two details explain most failed spreadsheet apps. First, permissions are per file, not per row: Google says protected ranges “shouldn’t be used as a security measure”, anyone who can view a sheet can make a copy of it, and viewers can still read hidden sheets. Second, apps built on a sheet usually load all of it: for spreadsheet sources, AppSheet fetches the entire sheet and only then filters it, and its own documentation says security filters “aren’t a complete security solution.”
Google also warns that Apps Script quotas are “subject to elimination, reduction, or change at any time, without notice,” so don’t design a business process that needs every one of them.
How often do spreadsheets go wrong?
More often than their owners think. In Raymond Panko’s compilation of field audits, errors turned up in 91% of 55 spreadsheets examined in the core studies. When researchers read Enron’s spreadsheets and emails, 24% of spreadsheets with formulas contained an Excel error, and 20.4% of spreadsheet emails were about versions, updates or revisions: version control by email.
The documented failures come from things a spreadsheet allows and a database refuses:
- A number typed over a formula. In 2026 the Alexandria, Virginia transit agency DASH found that a $3.2 million hard-coded entry in its tracking workbook had overstated its year-end position; the workbook had no second review of its formulas and manual entries.
- Copy and paste between sheets. JPMorgan’s London Whale risk model ran through spreadsheets filled in “by a process of copying and pasting data from one spreadsheet to another”, and one formula divided by a sum instead of an average, muting the volatility it reported by a factor of two.
- Silent truncation. In 2020 Public Health England left 15,841 COVID-19 cases out of its daily figures because, as the BBC reported, its process used the old XLS format, which holds 65,536 rows per sheet.
- Values changed on entry. Excel turns gene names such as SEPT1 into dates, and 30.9% of papers with Excel gene lists in one study had the errors; geneticists renamed the genes rather than wait for a fix.
- Hidden data that isn’t hidden. A spreadsheet released by the Police Service of Northern Ireland carried hidden data that exposed all 9,483 officers and staff, and it was fined £750,000.
Each of these maps to a database feature: types and check constraints for the typed-over number and the converted value, one table instead of copied sheets, no row ceiling, and permissions enforced on the server instead of hidden columns.
What are your options for turning a spreadsheet into an app?
There are five routes, from least to most change:
- Stay in Google Sheets and add Apps Script. Custom menus, form-driven entry, scheduled emails. Cheapest, and still a spreadsheet underneath.
- Put an app on top of the sheet with AppSheet or Glide. A mobile-friendly app in hours, with the sheet still holding the data.
- Use a no-code portal such as Softr on top of Sheets or Airtable, when outsiders such as customers need to log in.
- Move the data to Airtable, or build internal screens in Retool or Power Apps. A real database feel without writing an app.
- Build a custom app on a real database. Postgres underneath, your own screens on top, and the spreadsheet kept only as a report.
What do AppSheet, Glide, Softr, Airtable, Retool and Power Apps cost?
Prices from each vendor’s pricing page on October 11, 2026. Most charge per user, so the bill grows with your team, not with your data.
| Platform | Price | How it counts | Data limits |
|---|---|---|---|
| AppSheet | Starter $5, Core $10, Enterprise Plus $20 per user a month | Per user; Core is included in most paid Google Workspace plans | 100,000 rows on a Google Sheet |
| Glide | Basic $25, Plus $50, Pro $125 a month | Credits; this is GlideOS, a new product | Not published |
| Glide Classic | Business $199 a month billed yearly, 30 users | Users, plus 5,000 updates then 2¢ each | 25,000 rows from a spreadsheet |
| Softr | Basic $19, Pro $99, Business $329 a month billed yearly | Team and client users per plan, such as 10 team and 50 client on Pro | 50,000–1,000,000 records in its own database |
| Airtable | Team $20, Business $45 per collaborator a month billed annually | Per collaborator | 50,000 or 125,000 records per base |
| Retool | Team: $10 per builder, $5 per internal user a month billed annually | Builders and users priced separately | Your own database |
| Power Apps | Premium $20 per user a month, paid yearly | Per user; the per-app plan is no longer sold to new customers | Dataverse or your sources |
For a team of ten using one internal app, as an illustration at list prices:
| Option | Monthly cost |
|---|---|
| AppSheet Core | $100, or nothing extra if your Workspace plan includes Core |
| Retool Team, 1 builder and 9 users | $55 |
| Softr Pro, up to 10 team users | $99 |
| Glide Classic Business, up to 30 users | $199 |
| Airtable Team, 10 collaborators | $200 |
| Power Apps Premium | $200 |
| Custom app | About $65 to run, plus the build, as in Custom CRM vs HubSpot |
At ten people, the platforms are cheap and fast. The gap opens when you add users, need customers to log in, or need permissions the platform can’t express.
How do you turn a spreadsheet into a database?
This is the step that decides whether the app works, whichever route you take. Take a typical jobs sheet:
| Date | Customer | Phone | Address | Job | Assigned | Status | Price | Paid? |
|---|---|---|---|---|---|---|---|---|
| 10/03/2026 | Customer A | 555-0101 | 1 Main St | Repair | Tech A | Done | 240 | Y |
| 2026-10-04 | Customer A | 555-0101 | 1 Main St | Service | Tech B | done | 120 | yes |
| Oct 5 | Customer B | 9 Oak Ave | Repair | Tech A | Completed |
Three problems hide in three rows. The customer is copied on every job, so a new phone number has to be changed in many places. Status and paid are free text, so nothing can count them reliably. And dates arrive in three formats, so sorting by date is wrong.
The fix is to split the sheet into tables with one fact in one place, and let the database refuse bad data:
create table customers (
id bigint generated always as identity primary key,
name text not null,
phone text,
address text,
unique nulls not distinct (name, phone) -- a missing phone still counts
);
create table staff (
id uuid primary key, -- the user's login id
name text not null
);
create type job_status as enum ('quoted', 'scheduled', 'in_progress', 'done', 'cancelled');
create table jobs (
id bigint generated always as identity primary key,
customer_id bigint not null references customers (id),
scheduled_for date not null,
job_type text not null,
assigned_to uuid references staff (id),
status job_status not null default 'quoted',
price numeric(10, 2) check (price >= 0),
paid_at timestamptz,
created_at timestamptz not null default now()
);A status outside the list, a negative price or a job with no customer now fails at the database, not three weeks later in a report.
Import with a reject pile, not with hope
Export the sheet as CSV and run every row through the same rules. Rows that pass are imported; rows that don’t go back to a person with the reason, instead of being guessed at:
type Row = Record<string, string>;
const STATUS: Record<string, string> = {
done: 'done', completed: 'done', complete: 'done',
scheduled: 'scheduled', booked: 'scheduled',
quote: 'quoted', quoted: 'quoted',
'in progress': 'in_progress', cancelled: 'cancelled', canceled: 'cancelled',
};
function isoDate(s: string): string | null {
const t = s.trim();
if (/^\d{4}-\d{2}-\d{2}$/.test(t)) return t;
const us = t.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/); // MM/DD/YYYY
return us ? `${us[3]}-${us[1].padStart(2, '0')}-${us[2].padStart(2, '0')}` : null;
}
export function clean(row: Row, line: number) {
const problems: string[] = [];
const date = isoDate(row['Date'] ?? '');
const status = STATUS[(row['Status'] ?? '').trim().toLowerCase()];
const price = row['Price']?.trim() ? Number(row['Price'].replace(/[$,]/g, '')) : null;
if (!date) problems.push(`date "${row['Date']}" isn't a date`);
if (!status) problems.push(`status "${row['Status']}" isn't one of the allowed values`);
if (price !== null && !(price >= 0)) problems.push(`price "${row['Price']}" isn't a number`);
if (!row['Customer']?.trim()) problems.push('no customer');
const paid = /^(y|yes|true|paid)$/i.test(row['Paid?']?.trim() ?? '');
return problems.length
? { ok: false as const, line, problems }
: { ok: true as const, date, status, price, paid, customer: row['Customer'].trim() };
}“Oct 5” lands in the reject pile on purpose: a date without a year is a question for a person, not for code. Most imports take two or three rounds of fixing rejects, and each round is minutes.
Give each person only their rows
This is the thing a shared spreadsheet can’t do. In Postgres, row-level security lets the database itself decide which rows each signed-in person can read or change. On Supabase, staff seeing only the jobs assigned to them is one policy:
alter table jobs enable row level security;
create policy "staff see their own jobs"
on jobs for select
to authenticated
using (assigned_to = (select auth.uid()));Because the rule lives in the database, it holds for the app, the API and any report that connects later. If it seems not to work, the usual causes are in Supabase RLS not working?.
Keep the spreadsheet as a report
People who like the spreadsheet can keep one: a scheduled export to a read-only sheet each night. The difference is that the sheet becomes a view of the data, not the place the data lives, so nobody can break the system by sorting a column.
Which should you choose?
Stay in Sheets with Apps Script, if
- One team edits, everyone can see everything, and you mainly want forms, menus and emails.
AppSheet or Glide, if
- You want a phone-friendly app this week, the data is modest, and your people already have Google accounts.
Softr or Airtable, if
- Customers or partners need to log in and see their own records, and the workflows are standard.
Retool or Power Apps, if
- The screens are internal, your data already sits in a database or Microsoft 365, and you have someone technical to own it.
A custom app, if
- Per-person permissions, an audit trail, approvals or integrations matter, or per-user pricing would grow with your team.
- You want the data in your own database and the code in your own repository.
We build the last kind as internal tools, usually with the spreadsheet import, roles and a nightly export to a sheet included, in about a week. See CRMs and internal tools. If AppSheet or Glide would do the job, we’ll say so.
How do you move from a spreadsheet to an app without breaking anything?
- Freeze the columns. Agree the final list of fields and what each one means before anything is built.
- Write the rules down. Allowed statuses, required fields, who can see and change what.
- Build the schema, then import. Run the import, fix the rejects in the sheet, and repeat until the pile is empty.
- Run both for a week. The app is the source of truth; the sheet becomes read-only and is compared each day.
- Cut over. Lock the old sheet, keep it as an archive, and switch any automations to the app’s data.
- Keep the export. The nightly read-only sheet means nobody loses their favorite view.
What next?
Open your most important spreadsheet and count three things: how many people edit it, how many columns hold free text that should be a fixed choice, and how many other tools read from it. If any of those numbers worries you, it’s time to move. When you’re ready, send us the sheet’s column list or see how a one-week internal tool build works.
Sources
- Google — Files you can store in Google Drive (Sheets limits)
- Microsoft — Excel specifications and limits
- Google — Sheets API usage limits
- Google — Apps Script quotas
- AppSheet — Spreadsheet data source limits
- Google — Protect, hide and edit sheets
- AppSheet — Security filters
- Raymond Panko — Spreadsheet field audits
- Hermans and Murphy-Hill — Enron’s spreadsheets and related emails (ICSE 2015)
- DASH — Board meeting presentation, September 2026
- US Senate hearing record — JPMorgan Chase whale trades (task force report)
- Public Health England — Statement on delayed reporting of COVID-19 cases (2020)
- BBC — Excel error and lost COVID-19 cases (2020)
- Microsoft — When a data set is too large for the Excel grid
- Abeysooriya et al. — Gene name errors in supplementary data (PLOS Computational Biology, 2021)
- Bruford et al. — Guidelines for human gene nomenclature (Nature Genetics, 2020)
- UK Information Commissioner’s Office — PSNI fine (2024)
- AppSheet — Pricing
- Google Workspace — Editions that include AppSheet Core
- Glide — Pricing
- Glide Classic — Pricing
- Softr — Pricing
- Airtable — Pricing
- Airtable — Plans and limits
- Retool — Pricing
- Microsoft Power Apps — Pricing
- Microsoft — Power Platform licensing options