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.

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. Editing stays record-oriented in a typed drawer — Power Tables is the database, not the spreadsheet; that's AI Sheets' job. An optional Ask AI agent answers counts, sums, and averages from your tables so nobody writes a query by hand — off by default until an admin turns it on.

Productivity Utility

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 or Excel files up to 100 MB with an explicit header-mapping step, streaming progress, and per-row error reporting.

Eleven column types — text, long text, number, currency, boolean, date, datetime, select with options, email, url, and People — validated on every write.

Author saved views (filters + sort + visible columns) straight from the grid; every table starts with an "All rows" view, and views are what Live Boards bind to.

Filter per column, search full text, and scroll with keyset pagination — no row-count ceilings, and deep pages stay as fast as page one.

Edit records in a drawer with one typed input per column — date pickers, dropdowns, yes/no, a people picker — with optimistic concurrency so edits never silently collide.

Export any view to CSV or Excel — the current filters, search, sort, and visible columns — as a background task with a download when it's ready (Excel capped at 100,000 rows).

Enforce validation rules per column — required values, min/max bounds for numbers and currency, regex format patterns for text — on every row write, including per-row on imports.

See who changed what: a collapsible History panel in the row drawer shows per-field old-to-new changes with the actor, kept for 180 days.

Schedule a nightly pull per table — from a public https URL, an authenticated endpoint (Data Feed connection), or an SFTP server — in replace or append mode, with a Run now button and failures reported right on the table page.

Bulk edit selected rows: set one column's value across the whole selection as a tracked job with per-row validation errors reported — People columns swap the value box for the people picker.

Start from a template — Asset registry, Visitor log, Store performance, or Incident tracker prebuilt schemas in the New Table drawer.

Integrate over the REST API: list tables, read rows with keyset pagination, run filtered aggregates, and ingest rows under read:power_tables / write:power_tables token scopes.

Ask AI answers data questions directly — filtered counts, sums, averages, minimums, and maximums over any table (agent toggle, off by default).

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, People
Select columns with admin-defined option lists
Rename columns and tables at any time (metadata-only, instant at any size)
People/user column type Pick people with the shared people picker in the row form; names render in the grid and in CSV exports
Validation rules per column: required, min/max (number and currency), regex format pattern (text) Enforced on every row write — including per-row on imports and the REST API
Prebuilt table templates in the New Table drawer: Asset registry, Visitor log, Store performance, Incident tracker

Import & Data Entry

CSV import up to 100 MB, streamed with background progress tracking
Header-mapping step before every import — bind each file column to a table column, create it as text, or skip it
Per-row import error reporting (row number + message) with a skipped-row count
Auto-create missing CSV columns as text during import
Row-level editing in a drawer with typed inputs (date pickers, select dropdowns, yes/no)
Optimistic concurrency on edits — conflicting saves are caught, never silently overwritten
XLSX / Excel import Same two-step flow as CSV, up to 100 MB; the workbook's first sheet imports
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 — a Data Feed connection sends a bearer token, basic auth, or custom header with the nightly pull, and an SFTP connection fetches a remote file path instead of a URL
CSV and Excel (XLSX) export View-aware — exports the current filters, search, sort, and visible columns as a background task with a download; Excel is capped at 100,000 rows, CSV has no cap
Bulk edit: set one column's value across selected rows as a tracked job People columns swap the free-text value for the people picker; blank clears the value either way; per-row validation errors are reported on the task card
Bulk delete of selected rows as a tracked background job

Views, Query & Search

Saved views capturing filters, sort, and visible columns, authored from the grid
Every table starts with an "All rows" view; views are the binding point for Live Boards
Per-column filters with type-aware operators (text, number, date)
Full-text search across text columns
Keyset pagination — constant-time scrolling at any depth, no row-count ceiling
Sort on any column, with an "index this column?" prompt when an unindexed sort would be slow
Ask AI aggregates: filtered counts, sums, averages, min and max answered directly by the Power Tables agent Behind the Settings agent toggle (off by default); available to every member with app access, like search

Performance & Scale

One real Postgres table per user table — SQL-native sort and filter
User-marked per-column indexes, built in the background with tracked progress
Configurable quotas: tables, rows per table (up to 5 million), columns, indexes
Row counts shown as fast estimates, with exact count on request

Access & Governance

Admin-managed authoring — admins create tables, import data, and edit records
Every member with app access can view, filter, and search tables
Archive tables (instantly hidden, purged after a grace window)
Row change history A History panel in the row edit drawer shows who changed which field, old to new, kept for 180 days. Imports and bulk inserts are deliberately not logged row-by-row — the import task is the audit there
Public REST API List tables, table structure, keyset row reads, filtered aggregates, and admin row ingest — under least-privilege read:power_tables / write:power_tables token scopes
Mobile-optimized views Read-only on mobile — table cards and searchable row cards; importing, exporting, and editing stay on desktop

Limits & Specs

Column types: 11 (text, long text, number, currency, boolean, date, datetime, select, email, url, People)
Rows per table: 500,000 default, configurable up to 5 million
Tables per tenant: 5 default, configurable up to 25
Columns per table: 25 default, configurable up to 100
Indexed columns per table: 4 default, configurable up to 7
Views per table: 100
Row history retention: 180 days
Import file size: Up to 100 MB (CSV or XLSX), streamed
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 filters to "warranty ends in 90 days" and saves it as a view the whole team can open.

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.

Resources

Power Tables Datasheet (PDF)

Datasheet

Features, capabilities, pricing model, and FAQ on one downloadable sheet — share it with your team.

Power Tables app overview

Help Article

What it is, column types, CSV and Excel import and export, scheduled imports, validation rules, row history, saved views, indexes, the REST API, quotas, and how pay-as-you-go row metering works.

Your tables

Help Article

The live surface — create typed tables, import CSV or Excel files, export views to CSV, author saved views, and mark columns for indexing.

Feed a Live Board from a saved view

Guide

Boards bind to Power Tables saved views — author the view here, then build the leaderboard, stat tile, or table display in Live Boards.

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.

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.

Power Tables is admin-managed: admins create tables, define columns, import CSVs, and edit records. Every member with access to the app can open tables, filter, sort, and search — viewing is not an admin privilege.

Yes to both. Import accepts CSV and Excel (XLSX) files 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: it captures the grid's current view — filters, search, sort, and visible columns — and runs as a background task with a download button when it's ready. Excel export is capped at 100,000 rows; CSV has no cap. For programmatic access there is also a REST API.

Yes. Each table can have one scheduled import: a nightly pull of a CSV or Excel file, in replace mode (the source is the system of record — the table's rows are cleared and re-imported) or append mode (every run adds rows, for accumulating logs). A Run now button triggers it on demand, and the last run's status — including failures — shows on the table page. The 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 from an SFTP server instead of a URL.

Yes, for single-row changes. Every add, edit, and delete made through the row drawer, bulk edit, or the REST API is logged per field — who changed it, old value to new value — and shown in a History panel inside the row's edit drawer. Entries are kept for 180 days. Imports and bulk inserts are deliberately not logged row-by-row; the import task record is the audit trail there.

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 admin users — 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 admin 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.

No — a column's type is fixed at creation to keep the underlying storage honest. Add a new column with the right type instead. Renames, by contrast, are instant at any table size.

No, deliberately. Power Tables stores and serves typed data; it does not compute derived cells. If you need formula work, that is AI Sheets' job — and for display-time math like trends, Live Boards can compare two numeric columns of the same view to render up/down arrows.

Defaults are 5 tables, 500,000 rows per table, 25 columns, and 4 indexed columns per table — each configurable by an admin up to 25 tables, 5 million rows, 100 columns, and 7 indexes. Imports stop cleanly at the row quota and report how many rows were skipped.