Get AI summaries of any video or article — Sign up free
Create Nested Columns (and Columns in Toggles) in Notion thumbnail

Create Nested Columns (and Columns in Toggles) in Notion

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

Build multi-column layouts on a normal page first, then convert that page into a wrapper block to preserve nested columns.

Briefing

Notion’s nested multi-column layouts aren’t blocked by the app so much as by a workflow limitation: you can’t directly drag blocks into place to create columns inside certain “special” containers. The fix is to build the columns first in a normal page, then convert that page into a different block type—so the multi-column structure carries over intact. That same conversion trick then works inside Toggle blocks, Template blocks, and Synced blocks, enabling complex layouts that many people assume are impossible.

The core technique starts with creating a standalone page and placing the content you want inside it. Once the content sits on that page, Notion allows standard multi-column creation by dragging blocks side-by-side. After arranging the layout, the next step is the key: right-click (or use the six-block icon) and “turn into” a different block type. Converting the page into something like a heading or a to-do list effectively “wraps” the existing multi-column layout under the new block. The heading/to-do title becomes the wrapper’s label, and the rest of the content remains in its column structure. As long as the converted page is already positioned under an existing column on the parent page, the nested columns persist.

That principle scales to the containers people struggle with. To get columns inside a Toggle block, create the Toggle (or convert the page into a Toggle), then apply the same “turn into” step so the page’s multi-column layout becomes the Toggle’s internal content. For Synced blocks, the workflow is analogous: convert the page into a Synced block first, then use the “turn into” conversion to swap the page into a block type that preserves the column separation. Template blocks work the same way, too—build the multi-column layout on a page, convert it into a block type that can live inside the template, and then duplicate the template as many times as needed while keeping the nested columns.

Two practical gotchas come up. First, copy/paste breaks multi-column layouts: pasting multi-column content collapses it into a single column. The workaround is planning ahead—copy the original page that still has the multi-column structure before converting it into nested form, then reuse that source when needed. Second, converting the layout into a wrapper block (like a Text block) keeps the column group nested under that wrapper. That means the whole structure can be moved, edited, and duplicated as a unit—useful for storing alternate versions inside a Toggle for later.

Finally, inline databases have their own column frustration: they can’t be dragged into side-by-side positions like other blocks. The workaround is to create the multi-column layout using a different block type first (for example, headings), then drag the inline databases into the appropriate column slots underneath. After the databases are placed, the temporary blocks can be deleted without destroying the column layout. Together, these steps unlock nested columns across Toggle, Template, Synced, and inline database scenarios—without relying on Notion features that appear to be missing.

Cornell Notes

Nested columns in Notion are achievable even inside Toggle, Template, and Synced blocks, but only if the multi-column layout is created first on a normal page. After arranging content into columns, convert that page into another block type (“turn into” a heading, to-do list, text block, Toggle, Synced, or Template-compatible wrapper). The conversion preserves the multi-column structure as long as the converted page sits under an existing column on the parent page. Inline databases require a similar workaround: create the column layout with other blocks first, then drag the inline databases into the column slots.

Why do nested columns seem impossible in Toggle/Template/Synced blocks, and what workflow bypasses that limitation?

Directly dragging blocks to form columns inside those containers often fails. The workaround is to build the multi-column layout on a regular page first (where side-by-side dragging works), then convert that page into the target container-compatible block type using the “turn into” option. Because the conversion wraps the already-built column layout, the nested columns remain intact when placed under an existing parent column.

What exactly does the “turn into” step do for nested columns?

After creating columns on a page, right-click (or use the six-block icon) and choose “turn into” something like a heading or a to-do list. The page title becomes the wrapper’s label, and the rest of the page content stays in its multi-column arrangement. Deleting the wrapper label is optional; the columns persist.

How can columns be created inside a Toggle block?

Create a Toggle block (or convert the page into a Toggle), then place the multi-column page content inside it. Apply the same “turn into” conversion so the blocks become separated under the Toggle wrapper. When the Toggle is untoggled, the internal multi-column layout appears.

How do Synced blocks and Template blocks fit into the same trick?

For Synced blocks, convert the page into a Synced block first (so it gets the Synced wrapper), then use “turn into” to apply a wrapper type that preserves the column separation. For Template blocks, build the multi-column layout on a page, convert it into a block type that can live inside the template, and then duplicate the template—each instance keeps the nested columns.

What breaks multi-column layouts during copy/paste, and how should someone plan around it?

Copy/paste collapses multi-column layouts into a single column. To avoid losing the structure, copy the original page that still contains the multi-column layout before converting it into nested form, then reuse that source when creating additional instances.

How can inline databases be placed into multi-column layouts despite drag-and-drop restrictions?

Inline databases can’t be dragged side-by-side with other blocks to form columns. The fix is to create the multi-column layout first using another block type (like headings), then drag the inline databases into the column slots beneath those blocks. After placing the databases, the temporary blocks can be removed while the column layout remains.

Review Questions

  1. What sequence of steps preserves a multi-column layout when converting a page into a wrapper block?
  2. Why does copy/paste destroy multi-column layouts, and what alternative reuse strategy prevents that?
  3. How does the inline-database workaround differ from the nested-columns workaround?

Key Points

  1. 1

    Build multi-column layouts on a normal page first, then convert that page into a wrapper block to preserve nested columns.

  2. 2

    Use the “turn into” option (e.g., heading, to-do list, text block) so the wrapper label changes while the column structure stays intact.

  3. 3

    Place the converted page under an existing parent column; nested columns persist when the wrapper sits in the right column context.

  4. 4

    Apply the same conversion workflow inside Toggle, Synced, and Template blocks to get multi-column content within those containers.

  5. 5

    Plan ahead for reuse because copy/paste collapses multi-column layouts into a single column.

  6. 6

    For inline databases, create the column structure with other blocks first, then drag the inline databases into the column slots and delete the temporary blocks afterward.

Highlights

Nested columns work by building columns on a regular page first, then using “turn into” to wrap that page inside the desired container.
Toggle, Synced, and Template blocks can all host multi-column layouts when the column structure is created before conversion.
Copy/paste collapses multi-column layouts, so reuse requires copying the pre-converted multi-column source.
Inline databases can’t be used to form columns directly, but they can be inserted into pre-made column slots.

Topics

  • Nested Columns
  • Toggle Blocks
  • Template Blocks
  • Synced Blocks
  • Inline Databases

Mentioned