Loading...
Power Tables
Power Tables
Power Tables

Power Tables

Typed data tables that scale to millions of rows — import, query, and power Live Boards.

MangoApps

Category
Productivity & Utility
Version
1.0.0
Published
Jul 2026
Type
App

Overview

Every table in Power Tables is a real Postgres table inside MangoApps, not a grid held in your browser's memory — so a million-row table filters and sorts as fast as a thousand-row one. Import CSV or Excel files through an explicit column-mapping step with per-row error reporting, then filter, search, and sort at database speed, fast at any depth.

Number columns can be marked as counters, which turns them into − / + buttons on the desktop grid, in the row drawer, and on a phone. Those taps send the change, not the answer: the server applies it under a row lock, so two people counting the same shelf at the same moment both get counted instead of one silently overwriting the other. Each adjustment can carry a short note, and every single-row edit is logged field by field — who changed it, old value to new — for 180 days.

Every table starts with a saved "All rows" view; author more by filter, sort, and column layout — Live Boards binds to these views for leaderboards, stat tiles, and always-current displays. Date filters can be written as relative windows like "expiring in the next 30 days", recomputed every time the view is opened, so a saved slice keeps meaning what it says instead of freezing to the day it was saved. Editing stays record-oriented in a typed drawer — Power Tables is the database, not the spreadsheet; that's AI Sheets' job.

Automation rules react to row events or run on a schedule: update fields, notify a person, send email, request an approval, open a task, call a webhook, lock or archive a row, or run an AI fill, digest, or anomaly alert. Sharing is per table — leave a table open to everyone with app access, or restrict it and grant named people and groups viewer, contributor, or manager rights. A column that a rule, a board, or a bound form depends on cannot be archived out from under it; the refusal names what is using it.

Create typed data tables that scale to millions of rows, import CSV or Excel files with header mapping and per-row error reporting, and use saved views as the data source behind Live Boards.

Highlights

Create typed data tables that scale to millions of rows — each one is a real Postgres table, so scale is bounded by indexes, not memory.
Import CSV files up to 500 MB (Excel up to 100 MB) with an explicit header-mapping step, streaming progress, and per-row error reporting — or schedule a nightly pull from an https URL, an authenticated endpoint, or an SFTP server.
Count stock without typing: mark a number column as a counter and it becomes − / + buttons on desktop, in the row drawer, and on a phone — the server applies each tap as a change, so simultaneous counts never overwrite each other.
Author saved views (filters + sort + visible columns) straight from the grid, including relative date windows like "expiring in the next 30 days" that recompute every time they're opened — and Live Boards binds to those views.
Automate the table: rules fire on row events or on a schedule to update fields, notify people, send email, request an approval, open a task, call a webhook, lock or archive rows, or run AI fill, digest, and anomaly alerts.
Share per table, with a 180-day per-field change history — and columns that a rule, board, or bound form depends on can't be archived out from under them.
Pay-as-you-go on rows stored: no per-seat charge, no floor, and tiered unit prices that drop as your data grows.

Capabilities

Tables & Column Types
  • Typed columns: text, long text, number, currency, boolean, date, datetime, select (with options), email, url, user, file attachment
  • Validation rules per column: required, min/max (number, currency), date windows (date, datetime), regex format pattern (text, email, URL) Enforced on every row write — including per-row on imports and the REST API
  • Prebuilt table templates plus a curated Central Template Gallery Four built in (asset registry, visitor log, store performance, incident tracker); the last three arrive prewired with boards and automation rules
  • Describe a table in words and get a proposed typed schema to review before it's created Only your description is sent for drafting — never row data
Counting & Fast Capture
  • Counter columns — mark any number column and it renders − / + buttons instead of a typed field Works in the desktop grid, the row drawer, and on a phone
  • Simultaneous counts both land A tap sends the change, not the answer — the server applies it under a row lock, so two people counting the same shelf never overwrite each other. Counts floor at zero
  • Attach a short note to a count adjustment ("used in OR 2"), saved with the change
  • Barcode and QR scanning into text columns from a phone camera, with typed fallback Code 128, Code 39, EAN-13, EAN-8, UPC-A, QR
  • Count and read on mobile Table cards and searchable row cards, with counter steppers that work without JavaScript; adding rows, importing, and exporting stay on desktop
  • Bind a Form to a table so each submission becomes a typed row Append mode adds a row per submission; update mode matches an existing row on a chosen column and updates it — the stock-take pattern
Import, Export & Scheduled Sync
  • CSV import up to 500 MB and Excel up to 100 MB, streamed with background progress Per-row errors are reported with the row number and a skipped-row count
  • Header-mapping step before every import — bind each file column to a table column, create it as text, or skip it
  • Scheduled nightly import from an https URL or an SFTP server, per table Replace or append mode with a Run now button. Public https URLs need no setup; protected sources bind a connection configured once at /admin/integrations
  • Scheduled nightly export pushed to an SFTP destination SFTP only — an export must push somewhere credentialed
  • CSV and Excel export of the current view Captures the live filters, search, sort, and visible columns as a background task with a download
  • Bulk edit and bulk delete across a selection, as tracked background jobs Per-row validation errors are reported on the task card
Views, Query & Search
  • Saved views capturing filters, sort, and visible columns, authored from the grid
  • Relative date windows — today, this week, this month, this quarter, this year, last N days, next N days Recomputed server-side each time the view opens, so "expiring in the next 30 days" keeps meaning that; the same vocabulary drives Live Boards periods and view-watch alerts
  • Shared views and personal views Shared views belong to the table and can feed a Live Board; personal views are yours alone
  • Full-text search across text columns, plus per-column type-aware filters
  • Summary and Breakdown — filter-aware column stats for exactly what's on screen, and the same stats grouped by a dimension
Automations & Alerts
  • Rules that fire on row events — row created, row updated, a specific field changed, row deleted
  • Rules that run on a schedule — every N minutes (15 minute minimum), daily, or weekly
  • Actions: update fields, notify a user, send email, request an approval, create a task, call a webhook, lock a row, archive a row, delete a row
  • AI actions: fill a column, post a summary digest, raise an anomaly alert
  • Approval steps with per-outcome follow-on actions An approved or rejected decision runs its own action block in the row's context
  • A rule that keeps failing pauses itself and tells its owner After five consecutive failures — plus an emergency stop for all rules on a table
  • Schedule rules can never message per matching row Deliberate guard — a scheduled rule matching 10,000 rows updates them silently or reports once as a digest; it cannot send 10,000 notifications
  • Watch a saved view and alert when it crosses a threshold Fires on the crossing, not every night it stays over
Access, Audit & Recovery
  • Per-table sharing Three app-level tiers decide the baseline — admins configure, contributors write rows, everyone else reads. On top, each table is open to everyone with app access or restricted and named explicitly by granting users or groups viewer, contributor, or manager rights, each with an optional expiry
  • Per-field change history Who changed which field, old value to new, kept 180 days and shown in the row's own History panel. Imports and bulk inserts are deliberately not logged row-by-row — the import task is the audit there
  • Columns in use can't be archived out from under what depends on them A column referenced by an automation rule, a Live Board, or a bound form is refused — and the refusal names each one. Renaming is always safe
  • Deleted rows land in a 30-day recovery bin and restore as a batch Archiving a table is likewise reversible for 7 days, with a warning before it is purged
  • Public REST API List tables, table structure, keyset row reads, filtered aggregates, and row creation — under least-privilege read:power_tables / write:power_tables token scopes. Updating and deleting rows are not exposed
Limits & Specs
  • Column types: 12 (text, long text, number, currency, boolean, date, datetime, select, email, url, user, attachment)
  • Rows per table: 1 million default, configurable up to 10 million
  • Tables per tenant: 5 default, configurable up to 25
  • Automation rules per table: 25 default, configurable up to 50
  • Row history retention: 180 days (deleted-row recovery bin: 30 days)
  • Import file size: CSV up to 500 MB, Excel up to 100 MB
  • Excel export: Up to 100,000 rows (CSV export has no cap)
  • Billing model: Pay-as-you-go per 1,000 rows stored per year — no per-seat charge, no floor
  • Row pricing tiers: $1.20 per 1,000 rows/yr (first 1M), $0.36 (to 10M), $0.24 above

Use cases

Store the sales ledger behind the leaderboard
An operations team imports a weekly 800,000-row sales extract by CSV, saves a "This week — top sellers" view, and binds a Live Boards leaderboard to it — the data lives at database scale, the display stays current.
Keep an equipment or asset registry
Facilities builds a typed registry — serial number, location select, purchase date, warranty-end date, cost as currency — then saves a view filtered to "warranty ends in the next 90 days" that recomputes itself every time anyone opens it.
Count supplies on the shelf, from a phone
A clinical or stockroom team marks the quantity column as a counter and taps − as items are used, scanning the barcode to find the row. Two people counting the same shelf at once both get counted, and a note on the adjustment records why it moved.
Land recurring exports from other systems
A weekly export from a POS, ERP, or telephony system lands as a CSV import into the same table — new headers become text columns automatically, per-row errors are reported, and the table just keeps growing past spreadsheet limits.
Give the floor a searchable reference table
A parts catalog or price list with hundreds of thousands of rows becomes instantly searchable for every member with app access — full-text search plus per-column filters, no export-and-email cycle.
Track KPI snapshots for stat tiles
A team appends daily KPI rows — date, metric, value — and Live Boards stat tiles aggregate the saved view, so dashboards and signage always show the latest number without anyone rebuilding a chart.

FAQ

AI Sheets is the spreadsheet: cell editing, formulas, in-memory richness, capped at 50,000 rows. Power Tables is the database: typed records, millions of rows, saved views, and no formulas — the grid is a read-only viewport and edits happen record-by-record in a typed drawer. Use Sheets to work a dataset; use Power Tables to store one at scale and feed live displays. Two limits follow from that choice and are deliberate: there are no formulas or computed columns, and a column's type is fixed once created (add a new column with the right type instead — renames, by contrast, are instant at any table size). For display-time math like trends, Live Boards can compare two numeric columns of the same view.

Pay-as-you-go on rows stored: $1.20 per 1,000 rows per year for the first 1 million rows, $0.36 per 1,000 to 10 million, and $0.24 per 1,000 above that. There is no per-seat charge and no monthly floor. The app is available to every tenant with no license decision — it simply stays off until an admin enables it.

There are three app-level tiers: administrators create tables and define columns, contributors add and edit rows, and everyone else with app access can open tables, filter, sort, and search — viewing is not an admin privilege. On top of that, each table is shared individually: leave it open to everyone with app access, or mark it restricted and name its audience by granting specific people or recipient groups viewer, contributor, or manager rights. A grant on a restricted table can raise someone to contributor for that one table without giving them the app-wide tier.

Import accepts CSV files up to 500 MB and Excel (XLSX) workbooks up to 100 MB — for a workbook, the first sheet imports — through a two-step flow where you map each file column to a table column, create it as a new text column, or skip it before anything lands. Export goes the other way as CSV or Excel, capturing the grid's current view (filters, search, sort, and visible columns) as a background task with a download button when it's ready; Excel export is capped at 100,000 rows, CSV has no cap.

Both directions can also run unattended. Each table can have one scheduled import — a nightly pull in replace mode (the source is the system of record: rows are cleared and re-imported) or append mode (every run adds rows, for accumulating logs) — and one scheduled export, which writes the file to a path on an SFTP destination. A Run now button triggers either on demand, and the last run's status, including failures, shows on the table page. A scheduled import's source can be a public https URL with no setup at all, or a protected source through a connection an admin configures once at /admin/integrations: a Data Feed connection sends its credential (a bearer token, basic auth, or a custom header) with the nightly HTTPS pull, and an SFTP connection fetches a remote file path instead of a URL. For programmatic access there is also a REST API.

Yes, and that is the point of counter columns. Mark any number column as a counter and it stops being a typed field — it renders − / + buttons in the desktop grid, in the row drawer, and on a phone. A tap sends the change rather than the answer, and the server applies it under a row lock, so if a shelf holds 12 and two people each tap − at the same moment the result is 10, never 11. Counts floor at zero, and crossing zero can fire an automation so someone is told to reorder.

Each adjustment can carry a short note — "used in OR 2" — saved with the change. That rides the same audit trail as every other single-row edit: each add, edit, and delete through the row drawer, bulk edit, or the REST API is logged per field, showing who changed it and the old value to the new, kept for 180 days and shown in the row's own History panel. Imports and bulk inserts are deliberately not logged row-by-row; the import task record is the audit trail there.

Yes — that's what Mini Apps are, and they're created in App Builder rather than here. An admin describes what they need in plain language and gets a real app at its own address, with its own name, icon, and place in the sidebar. Underneath, it's Power Tables: the app's data is a table, its tabs are saved views, its behavior is automation rules, and its dashboard is a Live Board. Because it's a real app, it carries its own permissions, so a frontline user can be given a single narrow door — report a count for one item — without being able to browse or edit the table behind it. Mini Apps you create stay private to your tenant; they never appear in the public app directory, and their rows bill on the same Power Tables row meter rather than a second charge.

Yes. The REST API under /api/v1/power-tables lists tables, returns a table's structure (columns and views), reads rows with the same filter grammar and keyset pagination as the grid, runs filtered aggregates (count, sum, avg, min, max), and — for contributor users and above — ingests rows one at a time through the same casting, quota, and validation path as the row drawer. Access is by API token with least-privilege scopes: read:power_tables for reads, write:power_tables plus Power Tables contributor rights for writes.

No — that is the point of the architecture. Each table is a real Postgres table, so filters and sorts are SQL with real indexes, pagination is keyset-based (page one thousand is as fast as page one), and row counts are fast estimates rather than blocking scans. You mark the columns you sort and filter on for indexing, and index builds run in the background with tracked progress.

A saved view captures a filter, a sort, and a set of visible columns — authored straight from the grid, and every table starts with an "All rows" view. Live Boards bind to views, not raw tables, so the view is where you define exactly which rows and ordering a leaderboard or stat tile reflects. Refine the view and every board on it updates.

Yes — each table can carry automation rules. A rule fires either on a row event (row created, row updated, a named field changed, row deleted) or on a schedule (every N minutes down to a 15-minute floor, daily, or weekly). Its actions can update fields, notify a user, send an email, request an approval, create a task, call a webhook, lock a row, archive it, delete it, or run an AI action — fill a column, post a summary digest, raise an anomaly alert. Approvals carry per-outcome follow-on actions, so an approved row and a rejected row can take different paths. One guard is deliberate and worth knowing: a scheduled rule can never message per matching row, so a rule matching 10,000 rows updates them silently or reports once as a digest rather than sending 10,000 notifications. Every rule keeps a run history and has a Run now button. Separately, a view watch can alert when a saved view's count or aggregate crosses a threshold.