Get AI summaries of any video or article — Sign up free
New Notion Feature - Simple Tables (FINALLY!) thumbnail

New Notion Feature - Simple Tables (FINALLY!)

Thomas Frank Explains·
5 min read

Based on Thomas Frank Explains's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Notion’s simple table replaces database blocks for lightweight, text-based grids where full database features are unnecessary.

Briefing

Notion’s long-awaited “simple table” feature finally lets users drop a basic, non-database table directly into a workspace—avoiding the heavy database block when the goal is just a small grid of text. Instead of building everything as a database, users can now create a lightweight table with columns and rows, quickly enter data, and format cell contents with rich text, links, and even page mentions. For everyday use cases—tracking lists, comparing items, or logging notes—this removes a major friction point in Notion workflows.

Creating the table is straightforward: type the slash command “/table,” then choose the “simple table” option. The table supports adding columns and rows via plus icons or by dragging from the bottom-right corner to scale the grid. Navigation is fast for data entry: tab moves across columns, and enter moves down rows. Cells can be rearranged by dragging columns or rows, and the table can include headers using the six-dot handle that turns a row or column into a header row. There’s also a “fit to page width” control to keep the table readable without manual resizing.

A key differentiator from databases is how the table handles content. Simple tables accept rich text formatting inside cells—bolding text, applying background colors, and adding comments. They also support links: users can paste a URL directly into a cell or link to other Notion pages, including mentions of pages from within the table. This makes the table feel more like a structured note element than a database view.

For users who later need database-level power, Notion includes a bridge: the simple table can be “turned into database.” Doing so converts the first column into a typical “name” field (one page per row) while the remaining columns become text properties. Importantly, the reverse conversion can preserve formatting: turning the database back into a simple table retains rich text formatting in cells, except for link formatting in the example shown.

The feature still has notable limitations. Simple table cells currently only accept text—no other blocks can be created inside cells, and the slash menu won’t appear within a cell. Copy/paste and sorting are also constrained: users can’t copy across multiple cells directly, can’t paste multi-cell data from sources like Google Sheets in one go, and sorting is limited to manual drag-and-drop.

Workarounds rely on temporarily converting the table into a database. Once converted, users can sort using database controls and copy/paste multiple cells by selecting the relevant rows and pasting into a new table database with matching properties. After the data transfer or sorting is complete, it can be converted back into a simple table.

Finally, simple tables can be embedded into higher-level structures like synced blocks, template blocks, and database templates. That enables reusable patterns—for example, a “Task with Log” template where recurring tasks can include a simple table for recording what was done each time. Overall, the feature fills a gap between freeform notes and full databases, while still offering an upgrade path when more structure is needed.

Cornell Notes

Notion’s new “simple table” feature provides a lightweight alternative to database blocks for basic grids of text. Users can create tables with columns and rows, enter data quickly with tab/enter, reorder rows/columns by drag-and-drop, add header rows, and fit the table to page width. Cells support rich text formatting (bold, background color, comments) and links, including links to other Notion pages. The tradeoff is limited functionality: cells can’t contain other blocks, multi-cell copy/paste from external sources is restricted, and sorting is mostly manual. Converting the simple table into a database unlocks sorting and multi-cell operations, and converting back can preserve rich text formatting.

What makes Notion’s simple table different from using a database block for small data grids?

Simple tables are designed for “no frills” tabular notes. They let users add columns/rows, enter text quickly, reorder rows/columns, and format cell content with rich text (bold, background colors, comments) plus links (URLs and mentions of other Notion pages). Databases are more powerful but often overkill for simple lists because they add database-specific structure and views.

How does a user create and manage a simple table’s layout and headers?

A user types the slash command “/table” and selects the “simple table” option. Columns and rows can be added via plus icons or by dragging from the bottom-right corner. Data entry supports tab to move across columns and enter to move down rows. Reordering works by dragging columns or rows. Headers can be created using the six-dot handle to convert a row or column into a header row, and there’s a “fit to page width” control to adjust the table’s width.

What kinds of content can be placed inside simple table cells, and what can’t be done?

Cells accept text with rich formatting and links. Examples include bold text, background color, comments, and pasted URLs or links to other Notion pages. The major limitation is that cells can’t contain other blocks: typing “/” inside a cell won’t bring up the slash menu, and drag-and-drop of existing blocks into cells doesn’t work. Cells are effectively text-only right now.

Why does sorting and multi-cell copy/paste feel limited in simple tables, and what workaround exists?

Simple tables restrict sorting to manual drag-and-drop and limit multi-cell copy/paste and bulk paste from sources like Google Sheets or other tables/databases. The workaround is to temporarily “turn the simple table into database,” perform sorting and multi-cell copy/paste using database features, then convert the result back into a simple table.

How does converting a simple table into a database change its structure?

When converted, the first column becomes the database’s typical “name” column (one page per row). The remaining columns become text properties. Turning it back into a simple table can retain rich text formatting in cells (with link formatting noted as an exception in the example).

How can simple tables be reused across pages or workflows?

Simple tables can be placed into synced blocks, template blocks, and database templates. That allows the same table structure to be copied and kept in sync across multiple pages. A practical example shown is a recurring-task template where a “Task with Log” template includes a simple table to record what was done each time the task recurs.

Review Questions

  1. What specific limitations prevent simple table cells from acting like mini canvases (and what evidence in the workflow shows this)?
  2. Describe the conversion process between a simple table and a database, including what happens to the first column.
  3. When would someone choose to use the database workaround for sorting or bulk copy/paste instead of staying in simple table mode?

Key Points

  1. 1

    Notion’s simple table replaces database blocks for lightweight, text-based grids where full database features are unnecessary.

  2. 2

    Users can create simple tables with “/table,” add columns/rows, reorder them by drag-and-drop, and use tab/enter for fast data entry.

  3. 3

    Simple table cells support rich text formatting and links, including links to other Notion pages.

  4. 4

    Simple tables are currently text-only inside cells: other blocks can’t be created or pasted into individual cells.

  5. 5

    Sorting and multi-cell copy/paste are limited in simple tables, but converting to a database unlocks those capabilities.

  6. 6

    A practical workflow is to convert a simple table into a database for sorting/pasting, then convert back to regain the lightweight table view.

  7. 7

    Simple tables can be embedded into synced blocks and templates, enabling reusable structures like recurring-task logs.

Highlights

Simple tables let users embed basic tables without the overhead of a database block—ideal for small lists and structured notes.
Cells accept rich text (bold, background colors, comments) and links, including mentions of other Notion pages.
Turning a simple table into a database enables sorting and multi-cell copy/paste; converting back can preserve rich text formatting.
The biggest current constraint: cells can’t contain other blocks, and the slash menu won’t work inside table cells.
Simple tables can be used inside synced blocks and templates, including database templates for recurring-task logging.

Topics

  • Notion Simple Tables
  • Database Conversion
  • Table Formatting
  • Sorting Workarounds
  • Synced Blocks Templates

Mentioned