Block

Table

A grid of rows and columns — rows you type in yourself, rows filled from your data, or the exact grid a migrated document arrived with.

What it is for

A table lines information up in rows and columns. Use it for anything tabular: invoice lines, a price list, opening hours, a catalogue with pictures, a statement grouped by category. The editor calls the three shapes a table can have by the names you will see in the side panel:

Shape	What it is	Choose it when
Typed rows	A header row plus columns you define, and body rows you type in.	The content is fixed: opening hours, a price list.
Rows from data	The same columns, but the body rows are generated — one row per record of a list in your data, so the table grows with the data.	Invoice lines, order lines, any list of records.
Designed cells	A fixed grid of cells, merged cells and all, whose cells can hold other blocks (pictures, formatted text). The shape a migrated document arrives as, and the shape a table converts to when you set up Repeating rows or grouping.	A catalogue with pictures, merged headings, per-cell styling, repeating record rows, grouped statements.

Choose something else when:

you want one design repeated once per record that is not a grid — cards, labels, tickets — use a Repeater;
you want a simple bulleted or numbered list — use a List;
you want lines and boxes that look like a paper form — use a Ruled form.

Add and edit it

Pick Table in the block palette (group Data; searching "grid" or "line items" finds it). Clicking or dragging the Table choice adds a 3 × 3 table of typed rows. To pick another size, use Choose table size — the small arrow next to Table in the palette (hovering the Table tile opens it too), or the Choose table size… row right under Table in an Add block menu (the "+" on a selected Stack, Row, Repeater, table or Ruled form on the canvas, or under a group in the side panel's Contents list). Either one opens the same grid: point at, or arrow-key to, the columns × rows you want — up to 6 × 8 — switch Header row off if you do not want one, and click or press Enter. The table is added right there, at that size.

Edit cells, rows and columns

Double-click a cell to type straight into it; double-click a column header to rename that column. A data-filled table's body cells are generated, so there's nothing to type into — double-clicking one opens the column editor instead, where you map each column to a field.

Right-click any cell for "Insert row above", "Insert row below", "Delete row", "Insert column left", "Insert column right" and "Delete column", scoped to the exact row or column you clicked — this works the same way on a hand-typed table and on a migrated grid. It's refused on a data-filled table: its rows are generated from your data, so there's no literal structure to insert into. The same right-click menu also carries "Edit columns…"/"Edit table…", described next.

The same cell menu also has Fit column to contents for that cell's column, and on a designed grid Merge selected cells and Unmerge this cell (see "Working on several cells at once").

Without a mouse: Tab through the document to the table and press Enter — the cursor goes into its first cell (with the cell's text selected), and Tab moves from cell to cell. In a cell, press the Menu key or Shift+F10 and the same menu opens for that cell, with every action above. Enter or Escape leaves the cell and puts you back on the document; press Enter on the table again and you return to the cell you opened the menu from. With the table merely selected and no cell open, the menu offers the table's own actions instead.

An action the table can't take is still listed, greyed, with the reason on it rather than left out — so "why can't I delete this row" is answered where you asked it. The usual cases: the last row or the last column (a table keeps at least one of each), the header row of a table you typed (it holds the column names — "First row is a header" in Edit columns… turns it off), and a row that's part of a repeating record.

Inserting a column, or a row above or between the header rows, keeps the header row a header row: the new cells are header cells, so the row keeps its header fill and still repeats at the top of each page. A row inserted just below the header is an ordinary body row.

Select, merge and unmerge cells

Select the table, then drag across its cells — the second press draws a highlighted rectangle instead of picking the table up. Shift-click extends it. From the keyboard, in a cell, hold Shift and press an arrow key at the start or end of the cell's text (or while its whole text is selected): the highlight takes in the next cell, and more Shift+arrows grow or shrink it from the cell you started in. A rectangle always takes in a merged cell whole.

The table's bar then offers bold, italic, cell alignment, Merge cells, Unmerge cell and Clear, acting on exactly that rectangle; each is one undo. Pressing Delete with cells highlighted clears their text too — it never deletes the table (use the table's own menu for that). The cell menu (right-click inside the highlight, or the Menu key) has the same pair as Merge selected cells and Unmerge this cell. Merging joins the highlighted cells into one, including any cell that was already merged; unmerging splits a merged cell back into single cells.

When merging isn't possible it is greyed and says why — nothing is highlighted yet, the rectangle cuts through a merged cell, a selected cell holds a picture or other block whose text would land somewhere nothing draws it, or the merge would reach into or out of a row that repeats for each record. That last one is the same refusal the save would give you, quoted, so nothing you can do on the canvas produces a template that won't save. Unmerging a cell that isn't merged is greyed the same way.

Select the table itself (not a cell) and use its own menu (⋮) — or right-click the table — for "Add row", "Remove row…" and "Edit columns…"/"Edit table…". "Edit columns…" opens the full editor: the columns and the body rows. A migrated grid opens "Edit table…" instead, where you set per-cell style, mark the header row, work through a large grid cell by cell, and — via "Bind this table to data…" below it — turn the grid into a data-filled table. It merges and unmerges too; that pair is on the canvas as well (above), and both refuse for the same reasons.

Resize a column on the canvas

Select the table, then hover the line between two columns — the pointer turns into a resize handle. Drag it to resize those two columns together; a small chip tracks the width in millimetres and percent as you drag. Double-click the boundary instead to fit the left column exactly to its widest cell. Press Escape to cancel a drag partway through and leave the columns as they were.

The same fit is in the cell menu as Fit column to contents — right-click any cell, or press the Menu key from a cell — and fits that cell's own column; its right-hand neighbour gives or takes the difference (for the last column, its left-hand neighbour does), so the table stays the same width. Each fit is one undo. For an exact width, "Edit table…" and "Edit columns…" have a width field for every column.

Quick recipe: edit a table

Double-click a cell to type into it, or double-click a header to rename a column.
To insert or delete a row or column at a specific spot, right-click the cell next to it and pick the matching action — this works whether the table is hand-typed or migrated. From the keyboard, select the table, press Enter, Tab to that cell and press the Menu key or Shift+F10 for the same list.
To resize a column, select the table and drag the line between two columns (or double-click it to auto-fit), or choose "Fit column to contents" in a cell's menu.
To merge cells, drag across them (or Shift+arrow from a cell) and use the bar's Merge cells or the menu's Merge selected cells; to split one, use Unmerge.
For per-cell styling — fill colour, bold, alignment, vertical alignment, per-cell borders, and marking the header row — open "Edit table…" (the table's own ⋮ menu, or right-click any cell). This is a migrated-grid-only surface; a hand-typed table styles all its cells together from the Table style panel below, not per cell. Bold, italic and cell alignment are also on the bar once you've highlighted cells on the canvas.

Settings

Columns and rows (Typed rows and Rows from data)

Select the table and choose Edit columns… (the table's ⋮ menu, or right-click). The editor has three parts:

Fill rows from data (instead of typing them below) — switch it on to pick a list from your data; see "Rows from data" below.
Columns — First row is a header turns the header row on or off. Each column has its Data field (which field of a record feeds the column; shown when rows come from data), its Header text, a width as a percent of the table, Align (left, centre, right) and Format: Raw (as it arrives), Currency, Date, UPPER or lower. A format only ever applies to body cells, never to the header; a value the format cannot make sense of (words where a number was expected) is shown unchanged rather than blanked. Columns can be reordered and removed from their line.
Rows — the typed rows, for a table whose rows you type.

Table style (in the side panel)

Everything about how the table looks is in the side panel, and it is the same set of controls whichever shape the table has — one you built from columns, or one a migrated document brought in as a grid. Each control applies as you change it; there is no Apply button and no dialog to open.

Grid lines chooses which rules are drawn: every edge, horizontal rules only, an outer border only, or none. None is the clear way to get a borderless table — it removes the rules outright, rather than leaving an invisible border behind.
Border is the thickness, colour and line style of whatever Grid lines selects. It does not decide which rules are drawn.
Header fill and Zebra fill are the background behind the header row and behind every second body row. Clear either for no fill. On a migrated grid the header fill needs a header row: mark every cell of the top row as Header in "Edit table…", which that dialog tells you.
Table width and Table align are honoured everywhere — on the page, in the PDF, in the HTML export and in the Word (.docx) download. Table align does nothing until Table width narrows the table, because a full-width table has nowhere to move.
Cell padding is honoured everywhere too — on the page, in the PDF, in the HTML export and in the Word (.docx) download.

Page split

Select the table and the side panel's Page split section has Minimum start units: "Start on next page if fewer than N rows fit here". Leave it blank for the default (2), so a table does not start with a lone row at the foot of a page.

Good to know

A table that runs past the bottom of a page continues on the next one and repeats its header row there, so a long table stays readable.
"Add row" and "Remove row…" (which add or remove a whole row at the end) appear only for a table whose rows you typed in. A migrated grid instead gains and loses rows and columns through the right-click cell menu, or in bulk inside "Edit table…" — until you convert it with "Bind this table to data…", after which it behaves like any other data-filled table with no rows to add or remove by hand.
A display format only ever applies to body cells, never to the header. A value the format can't make sense of (words where a number was expected) is shown unchanged rather than blanked.
A cell that holds blocks is edited through those blocks — click one on the page, or find them under Contents in the side panel, grouped as "Row 2 · Col 1".
To add a block to a cell, drag it from the palette onto an empty cell or onto a cell that already holds blocks. Anywhere inside such a cell counts, not only its blocks, and while you drag a line shows where among its blocks the new one goes. On a table with repeating rows, dropping on any record's copy puts the block in the row design, so every record gets it.

Three ways to fill a table

Each path is taught on its own below. The right-click and keyboard editing above works on all of them, except where a path generates its rows (then there is no literal row to insert into).

Typed rows

The table you get from the palette. Double-click a cell to type; double-click a header to rename the column. Add row and Remove row… on the table's menu add or remove a whole row at the end. Nothing is bound to data, so the table never changes by itself. Style it with the Table style controls above and size its columns with Edit columns… or by dragging the line between two columns.

Rows from data

Select the table and choose a list in the side panel's list chooser (under Data path). Every list in your sample data is offered by name with its number of records; picking one shows its fields and first record and says what the table will print — "This table will print 2 rows, one per record, plus its header row". Then give each column a field under Columns; a column left "Not connected" prints empty, and the panel names it. No list yet? Create a list makes one (name, typed columns, two sample records) and uses it straight away; one Undo takes back both. "Edit columns…" offers the same list and field choices under "Fill rows from data". A list with no records prints the header row and nothing else, and so does a path that is not a list or has nothing behind it — the panel says which. Choosing "Not connected — rows are typed into the table" goes back to typed rows (and asks first if that would remove rows showing on the page).

Designed cells

A designed table keeps a fixed grid of cells that can hold pictures and formatted text, merge, and carry their own fills and borders. A migrated document arrives this way. From here you can bind the grid to data, make its rows repeat per record, or group the records.

Bind this table to data…

A table that arrived with a migrated document keeps the original's grid, which means it has a fixed number of rows and cannot be filled from your data. "Bind this table to data…" converts it: row 1 becomes the column headers, every row below it becomes the pattern for one record, and you point the table at a list in your data.

Choose the list from your data (or type its path, for example $data.items) and map each column to a field in it. The dialog shows three real sample rows before you commit, so you can see exactly what you will get.
Merged cells and cells that hold other blocks cannot convert, because the rows this conversion makes hold only text. The dialog names the exact cell that blocks it. Unmerge it in "Edit table…" and come back — or use Repeating rows instead, which keeps the designed cells exactly as they are, pictures, merges and per-cell styling included.
The rows have to line up: every body row needs one cell per column.
Per-cell fills, borders, fonts and vertical alignment on the body rows are replaced by the table's own header fill, alternating fill and grid lines. Everything the conversion will change is listed in the dialog before you apply it.
The rows the grid already had are kept, but a table filled from data never draws them: if the list is empty or not there, the table prints its header row and nothing else. They come back only if you disconnect the table from data.
One undo puts the whole grid back, exactly as it was.

Rows that repeat for each record

A designed grid can keep everything a designed cell holds — a picture, formatted text, merged cells, its own borders — and still grow with your data. Mark one row (or a few consecutive rows) as the design for one record, point them at a list, and the table prints that design once per record, in the order the list arrives.

This works on any table, not only a migrated one. A table you added yourself starts as plain columns and rows, which cannot hold a picture or a formatted paragraph in a cell — so Repeating rows offers to convert it to designed cells as part of the same step. It names anything that will read differently afterwards before you press the button (the one to expect: a column's display format, such as currency or a date, stops applying, because a designed cell prints exactly the text it holds). One undo puts the whole thing back, conversion included.

A migrated table that already has its line items typed out. A grid that arrived with a document usually holds four or five real lines, one row each. Repeating rows replaces them with ONE design, so the other rows have to go — and the panel shows you exactly which, before you press anything:

Rows that print after the list is where you say how many rows at the bottom are a total, a note or a signature rather than another line. The panel guesses by shape (a "Total" row that spans two columns is not a copy of a line row) and you can change it.
Everything between the design and those rows is listed as removed, by row number. Their text is not copied into your sample data, so copy anything you still need first.
The panel also names what is kept — pictures, merged cells, per-cell fills and fonts all survive, which is the difference between this and "Bind this table to data…" — and which cells it will fill from the list by matching their column heading to a field name. A cell whose heading matches nothing keeps its text and prints the same words in every record; nothing you wrote by hand is ever rewritten.
Two refusals, both by name: a row below the design that is not another copy of it (different cells, a merge) will not be deleted — count it among the rows that print after the list instead; and a header cell inside the rows you picked has to be moved above the design or unmarked, because a row that is part header cannot repeat.
One undo puts the whole table back exactly as it was, removed rows included.

How to set it up. Select the table, open Repeating rows in the panel on the right, and:

Pick the rows that make up one record — usually the single row below the header. A record's design may cover up to eight consecutive rows, so a line with a picture above its description is two rows of one record, not two records.
Say how many rows print after the list, if the table has a total or a note at the bottom.
Choose the list by name. The chooser offers the lists in your sample data with their sizes ("items — 2 records"); you never type a $data path. It then tells you exactly what the table will print — "These rows will print 2 times, once per record."
Say what each record is called (the default is item), which is the name the cells use: {{ $data.item.description }}.
Press the button, which says what it will actually do: Repeat these rows for each record, or … and remove the other 3 rows when there are other line rows to replace, or Convert to a designed table and repeat these rows on a table that still has to be converted. One undo puts the table back exactly as it was.

On a table already filled from a list, the conversion keeps that list and turns each column into one cell of the record's design, carrying its display format over as an expression. One difference it names for you: where a data-filled row shows a value its currency or date format could not read exactly as it arrived, the expression prints nothing instead.

Once it repeats, the same panel maps each cell of the design to a record field from a list — no binding to type — and a cell you wrote by hand (EUR {{ $data.item.amount }}, a format(…) call, two fields in one sentence) is shown as written by hand and is never rewritten for you. Stop repeating is there too, and says before you press it how many cells will stop resolving.

Adding or deleting a row moves the repeating rows with it, everywhere you can do it — the cell editor's toolbar and the right-click menu on the canvas. Deleting the only row of the design is refused with the reason, rather than quietly stopping the repetition.
The header rows above the design repeat at the top of every page.
On the canvas you see every record's copy, but they are all the SAME designed row: click into a cell in any copy and you are editing the design, so the change shows up in every record at once. There is no way to edit one record's copy on its own — a record's values come from your data, not from the template. The caret's bar says so while you type: a Row design chip, and — when the caret is in another record's copy — "Record 3's copy — editing the row design affects all records".
Sample record, in the same panel, picks which record's copy counts as the design: First, Previous, "Record 2 of 5", Next, Last, with that record shown on one line. It is a preview setting only — nothing about your data, the table or the order the records print in changes, it is not saved and it is not an undo step. What it changes is which copy's pictures and other blocks inside cells are the editable ones (the other copies' blocks are previews), and which record the field suggestions and condition results are worked out against. If you switch to a sample scenario that has fewer records, it says which record is missing and shows record 1 until you switch back. It is not offered while the list is empty — the sentence under the list already says what an empty list prints.
Rows below the design print once, after the last record, and they read the WHOLE list — so a "Total" cell written as {{ format(sum($data.items, 'amount'), 'currency') }} totals every record, not the last one.
Inside a record's rows, {{ $data.item.field }} is that record's field (item is the name you chose for a record), and anything the record does not carry — your company details, the document date — is still reachable the same way it is anywhere else.
A page break lands between whole records whenever a record fits on a page, never through the middle of one.
A record too tall for any page — several rows that together run longer than a page — breaks between its own rows instead, in order, with the header rows repeated above the part on the next page. Its first row is never left alone at the foot of a page: when only that row would fit, the record starts on the next page. A single row still taller than a page continues its text on the next page, as a long description does in a one-row record.
A record with a merged cell inside it has no row boundary to break at: if it is taller than a page, it moves to the next page whole and overflows there visibly. So does a tall record in a table that sits inside a Stack, a Row column or a Repeater — only a table placed directly on the page breaks a record between its rows.
A "Total" row travels with the last record, so it does not open a page on its own. When the last record and the totals together cannot fit one page, the record's last row moves down with the totals. Only when the record cannot give up a row — it has one row, or a merged cell — do the totals print at the top of the next page.
An alternating row colour alternates per RECORD, so a two-row record is shaded as one band.
If the list is empty, the design rows are never printed — they hold placeholders, and printing them would put template text into your document. You can give the table one line of text to print instead ("No items"); the totals still print.
A merged cell may not reach into or out of the repeating rows, and one record's design may cover at most eight rows. Either is refused as you do it — the Merge button says why — and refused again when you save, naming the cell or the number.
Records can be grouped (a heading and a subtotal per category) when each record already holds its own list of lines — see Grouped statements below.
At most 3000 records print; beyond that the table prints a visible "N record(s) omitted" line rather than quietly dropping them.
In Word, this exports as ordinary table rows — one Word table per page, with the header rows marked as repeating. It is a generated document, not a Word mail-merge template: there is no live repeating region inside the .docx.

Grouped statements

A statement that lists expenses by category, an invoice split into sections, a timesheet by project: each GROUP gets a heading, its own lines, and a subtotal, and the table ends with one grand total. The data has to arrive already grouped — each record is a group that holds its own list of lines, for example:

{ "groups": [
  { "name": "Travel", "lines": [ { "date": "2026-09-01", "description": "Train", "amount": 12 } ] },
  { "name": "Meals",  "lines": [] }
] }

A flat list of lines that the table would sort into groups by a field such as "category" is not supported — send the lines grouped.

To build one, start from a table that already repeats (above): its records become the groups.

Make the repeating rows cover the whole group — typically three rows: a heading row, the line row, and a subtotal row. Insert rows inside the repeating rows first if you need them.
In the side panel, under Groups, pick the rows that make up one line — the rows between the heading and the subtotal. At least one row of the group must stay outside the lines, as its heading or its subtotal.
Choose the list inside each group that holds its lines ("group › lines"). The panel tells you what each group in your sample data holds — "the 3 groups hold 2, 0 and 1 lines".
Say what each line is called (the default is line). It must differ from the group's name, so {{ $data.line.amount }} is a line's amount and {{ $data.group.name }} the group's name.
Press Group these rows. One undo puts the table back.

Once grouped, the same section maps each line cell to a line field, sets the text a group with no lines prints, and inserts totals without typing a formula:

Insert subtotal writes {{ format(sum($data.group.lines, 'amount'), 'currency') }} into the cell you choose in the subtotal row — it adds up THIS group's lines.
Insert grand total writes {{ format(sum(flatten($data.groups, 'lines'), 'amount'), 'currency') }} into a row after the groups — flatten joins every group's lines into one list, so it adds up every line of the table. An empty group adds nothing.
Either one names what the cell holds now before you press it, and each is one undo.

What prints, and where the pages break:

Each group prints its heading once, then its lines, then its subtotal. The header rows at the top of the table still repeat on every page.
A long group runs over as many pages as it needs. Its heading is not repeated on the next page — the lines simply continue under the table header.
A heading is never left alone at the foot of a page: it travels with the group's first line. A subtotal never opens a page: it travels with the group's last line. The grand total travels with the last group.
A group with no lines prints its heading, the text you chose for an empty group (if any), and its subtotal — €0.00 when it adds up nothing.
Totals are per group or for the whole table. There are no per-page totals and no "carried forward" sums at the foot of a page.
Groups nest one level only: a line cannot hold groups of its own.
A line taller than a whole page is not split through the middle — it moves to the next page whole, and overflows there visibly.
At most 3000 lines print across the whole table (and at most 3000 groups); beyond that the table prints a visible "N line(s) omitted" line.
Stop grouping keeps the records repeating; it says first how many cells naming the line will stop resolving.

Converting between shapes, and undoing it

You do this	What happens	Undo
Bind this table to data… on a designed grid	Row 1 becomes the headers and the rows below become the pattern for one record; the dialog lists everything that changes first.	One undo puts the whole grid back.
Repeating rows on a table of Typed rows or Rows from data	The table converts to Designed cells as part of the same step (a column's display format, such as currency or a date, stops applying — it is named before you press the button; a data-filled table's formats are carried over as expressions).	One undo puts the whole thing back, conversion included.
Stop repeating	The rows print once, as designed. The panel says first how many cells will stop resolving. The table stays a Designed-cells table.	One undo.
Group these rows / Stop grouping	Adds or removes the group level; the records keep repeating.	One undo.
Choose "Not connected — rows are typed into the table"	Goes back to Typed rows (and asks first if that would remove rows showing on the page).	One undo.

Examples

Each example is a complete template stored with this documentation and checked automatically.

Invoice lines from data, with currency columns and a repeating header

The example is table-1 (Rows from data). The table's Data path is $data.invoice.lines; four columns — Description (key description, wide), Qty (centred), Unit price and Amount (right-aligned, Currency); Header fill and Zebra fill set; Grid lines Horizontal rules only. Sample data:

{ "invoice": { "lines": [
  { "description": "Website design",     "qty": 1,  "unitPrice": 1200,  "amount": 1200 },
  { "description": "Hosting, 12 months", "qty": 12, "unitPrice": 15,    "amount": 180 },
  { "description": "Domain name",        "qty": 1,  "unitPrice": 12.5,  "amount": 12.5 }
] } }

Expected page: a header row (Description, Qty, Unit price, Amount) on a light fill, then three rows: "Website design | 1 | €1,200.00 | €1,200.00", "Hosting, 12 months | 12 | €15.00 | €180.00" and "Domain name | 1 | €12.50 | €12.50", with every second row shaded. Add a fourth line to the data and a fourth row appears; if the list ever ran onto a second page, the header row would repeat there. The currency symbol comes from the document's currency setting.

A catalogue with pictures: designed cells and a repeating record

The example is table-2 (Designed cells with Repeating rows). The grid has a header row (Photo, Product, Price) and one record row whose cells are: an Image whose Source is From data (product › photo, Cover, 20 × 20 mm), {{ $data.product.name }} and {{ format($data.product.price, 'currency') }} (right-aligned). Repeating rows is set to repeat that one row for $data.products, each record called product, with "No products" as the text for an empty list. Sample data: Oak table €480 and Reading lamp €59.90 (with photos), Gift card €25 (no photo). Expected page: the header, then three rows, one per product; the first two show their picture, the last shows "Picture unavailable". Unlike Rows from data, a cell here can hold a picture.

A grouped bill: groups of lines, a subtotal each and a grand total

The example is table-3 (Designed cells with grouping). The data arrives already grouped:

{ "groups": [
  { "name": "Travel", "lines": [ { "date": "2026-09-01", "description": "Train to Riga", "amount": 12 },
                                 { "date": "2026-09-03", "description": "Taxi", "amount": 18.5 } ] },
  { "name": "Meals",  "lines": [] },
  { "name": "Office", "lines": [ { "date": "2026-09-05", "description": "Printer paper", "amount": 9.9 } ] }
] }

The design has five rows: header; a group heading ({{ $data.group.name }}); a line row; a subtotal row with {{ format(sum($data.group.lines, 'amount'), 'currency') }}; and a grand-total row with {{ format(sum(flatten($data.groups, 'lines'), 'amount'), 'currency') }}. The group band covers the heading, line and subtotal rows; the line row is the inner "line". Expected page: header; "Travel", its two lines, "Subtotal Travel €30.50"; "Meals", "No lines", "Subtotal Meals €0.00"; "Office", its line, "Subtotal Office €9.90"; "Total €40.40".

A small typed grid with a merged title

The example is table-4 (Designed cells, no data): a "Opening hours" title merged across three columns, a header row, and three rows of times, the table 120 mm wide and left-aligned. It shows what Merge cells gives you; the "Closed" cell on Sunday spans two columns. A plain Typed-rows table looks the same minus the merges.

Output differences

PDF and HTML: everything above is drawn as laid out: grid lines, fills, merged cells, pictures in cells, repeating record rows, group headings and subtotals.
Word (DOCX): the table becomes an ordinary Word table. Table width, Table align and Cell padding are honoured there. Repeating rows and groups export as ordinary table rows — one Word table per page, with the header rows marked as repeating. It is a generated document, not a Word mail-merge template: there is no live repeating region inside the .docx.
Check the Preview's "Output differences this template uses" list before you download: it names anything in your table that Word simplifies.

Troubleshooting

The table prints only its header row. The list is empty, or the Data path is not a list or has nothing behind it. The panel says which. Pick the right list, or switch to a sample scenario that has records.
A column is empty. It is "Not connected" — give it a field under Columns, or in Edit columns…. A column's field name must match a field of the records.
A currency or date cell shows plain text. The value is not a number or a date the format can read; it is shown as it arrived rather than blanked. Check the data.
Borders look wrong or I want none. Grid lines decides which rules are drawn; Border is only their thickness, colour and style. Choose None for a borderless table. Table align does nothing until Table width narrows the table.
I cannot delete a row, or insert one. The action is listed greyed with the reason: a table keeps at least one row and column; the header row of a typed table is turned off with "First row is a header"; rows of a data-filled table are generated; a row that is part of a repeating record moves with the record.
Merge is greyed out. Nothing is highlighted, the rectangle cuts through a merged cell, a selected cell holds a picture or other block, or the merge would reach into or out of a repeating row.
A long record or table breaks oddly. Records move to the next page whole when they fit on a page; a merged cell inside a record cannot be broken, so such a record moves whole and may overflow. A table inside a Stack, Row column or Repeater only breaks between whole records.