Table Writeback - Overview
Astrato's Table object supports an editable writeback mode, allowing users to update, insert, and manage data directly inside a dashboard, with every change written back to the underlying data source in real time.
Unlike a static BI table, a Table with writeback enabled turns a dashboard into a collaborative, action-oriented workspace.
This walkthrough covers the Table's writeback capability as used in the mock Astrato Roadmap app, a live product roadmap built on Astrato and powered by Snowflake, demonstrating inline editing, row-level writeback, comments insertion, and automated Actions.
How It Works
When writeback is enabled on a Table, Astrato connects it directly to your data source via its pushdown SQL engine. When a user makes a change, Astrato generates and executes the appropriate INSERT or UPDATE statement against the live source, whether that is Snowflake, BigQuery, Databricks, or another supported platform. There is no intermediate layer, no export, and no manual sync step. The data is always live.
Each writeback target is a configured connection that maps table columns to source fields. You define this mapping once in the Object Properties panel; after that, Astrato handles the SQL automatically every time a user saves a change.
How It Is Triggered
The Table's writeback mode operates through an event-based model. When a user interacts with the table, editing a cell, completing a row, or submitting a new record, the table emits an event. There are two distinct events:
On values change (Update mode) fires when a user edits one or more cells in an existing row and confirms the change. In Row mode, this triggers once per row save, passing all changed columns and their new values together.
On values change (Insert mode) fires when a user submits a new record via the Insert tab. The event carries the field values from the new row.
These events are picked up by Astrato's Actions editor, where you define exactly what happens next: which writeback target to write to, which fields to map, what feedback to show the user, and how to handle errors. The table itself stays clean and reusable, while the writeback logic lives in a dedicated, auditable workflow.
In short: the user edits data in the dashboard, the table emits an event, the Action handles the write, and the user sees instant confirmation, all without leaving the page.
The Table in Writeback Mode
A Table with writeback enabled operates in two modes, selectable from tabs at the top of the component:
o Update Edit existing rows inline. Changes are written to the source on save.
o Insert Add new rows or records (e.g., comments) without leaving the dashboard.
Figure 1: Table showing dropdowns and free-text entry
Configuring the Table in the Editor
In Astrato's workbook editor, the Table is placed and configured like any other chart object. Selecting the table opens the Object Properties panel on the right, where all data, display, and writeback settings are managed. Writeback is enabled and configured from within this panel.
Figure 2: The Table selected in the Astrato editor, with the Object Properties panel open
Object Properties Panel
The Object Properties panel provides full control over the table's data, appearance, and writeback behaviour. It is divided into four tabs: Data, Filter, Style, and Layout.
Data Tab
The Data tab controls which columns are visible and their order. Each column has a visibility toggle and drag handle for reordering. Beneath the column list, the following sections appear:
o Limiting Hide zero values, Show Top N dimension values, and Extend query timeout.
o Export Visualization and export data limits, CSV formatting, custom null values, and metadata on export.
o Display settings Number of frozen columns (defaults to 0).
o Totals Toggle a summary totals row at the bottom of the table.
Figure 3: Object Properties Data tab showing Limiting, Display settings, Totals, and Writeback settings
Writeback Settings
The Writeback settings section sits at the bottom of the Data tab. This is where writeback is configured for the Table object:
o Writeback mode Cell: individual cell edits trigger a write immediately. Row: all edits in a row are batched and written when the user confirms. The Astrato Roadmap uses Row mode.
o Settings "Show all values from Astrato Roadmap" ensures the table always displays live source data, not cached values.
Actions: Automating Writeback
Astrato's Actions editor lets you wire up automated workflows triggered by table events. The Writeback Roadmap uses two choices of Action blocks:
one for updating existing rows
one for inserting new rows.
Update Table Action
Trigger: Update Table emits On values change
This action fires when a user edits a row and saves. It notifies the user, performs the writeback, then confirms success or surfaces an error:
o Try Show toast "Updating table..." (Info, persistent).
o Update the Astrato Roadmap dataset, passing: Columns changed, Values changed, Key columns, Key values, Updated By, and Updated At.
o On success: show toast "Writeback completed!" (Success, auto-hide).
o Catch Show toast "Writeback Error" (Error type).
Figure 4: Update Table action, on row edit writes changed values back to the mock Astrato Roadmap dataset
Insert Table Action
Trigger: Insert Table emits On values change
This action fires when a user submits a new comment via the Insert tab. It writes to a separate Comments writeback target:
o Try Show toast "Adding comment..." (Info, persistent).
o Writeback to Astrato Roadmap Comments Writeback, mapping three fields:
o ID get value at index 1 in Key values.
o Comment get value at index 1 in Values changed.
o Updated By Get Current User, Email (auto-captured, no manual input).
o On success: show toast "Comment added successfully!" (Success, auto-hide).
o Catch Show toast "Writeback Error" (Error type).
Figure 5: Insert Table action, maps comment, row ID, and current user email to the Comments writeback target
Key Takeaways
Enable writeback on any Table object to let users edit live data without leaving the dashboard, no forms, no external tools, no IT involvement.
Row mode batches all edits before writing, reducing round-trips and giving users a clear save gesture.
Actions wire up multi-step writeback workflows, toast feedback, error handling, and field mapping, with zero code.
Separate Insert and Update writeback targets keep row edits and comment inserts cleanly separated in the data model.
The Current User function automatically captures the author of every change, no manual attribution required.