Get AI summaries of any video or article — Sign up free
Coda.io finally has columns and workable subpages thumbnail

Coda.io finally has columns and workable subpages

Tools on Tech·
5 min read

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

TL;DR

Coda’s updated editor now supports side-by-side columns, making horizontal dashboard layouts workable.

Briefing

Coda’s latest editor update adds two long-requested capabilities—true side-by-side columns and “workable” subpages—that make it far easier to build dashboards and structured, repeatable workflows. For a longtime Notion user, the columns feature is the missing piece: the block-based layout previously made it difficult to drag elements horizontally, so comparisons and dashboard-style layouts were clunky. With columns now behaving as expected, Coda becomes much closer to the visual, at-a-glance experience people associate with Notion, especially for data-heavy overviews.

The practical payoff shows up in dashboard building. Side-by-side blocks let users place charts and other components next to each other so they can compare project status quickly—widening sections and arranging multiple elements for an “overview” view. That matters because Coda is often used for engineering and operations tracking, where the goal isn’t just storing information but monitoring whether work is on track. The update also supports richer, more readable layouts for teams that need to scan information fast.

Subpages are the second major improvement, and they address a specific usability gap. Earlier Coda subpages existed, but they weren’t as explicit as Notion’s database-record-as-page model. In practice, Coda could hide “page-like” behavior behind small UI affordances inside tables, which created confusion when explaining the system to others. Users might not realize that a particular field (for example, a string that represents a long text form) is meant to function like a structured page.

The new approach makes subpages more explicit by allowing a column to be defined as a “page.” That turns the cell into a full-fledged Coda page—closer to how Notion treats records as pages—so users can add components like charts and link back to other data. This is especially useful for building dedicated templates and workflows.

A concrete example is meeting notes. Instead of manually creating documents, a user can create a button that generates a new meeting note with default fields such as dates, attending people, an agenda, and prefilled sections. The system can also pull information from inside each meeting note back into an overview table—such as who was assigned to what or the key points—so people don’t need to open every note to understand the status.

While the creator notes Coda still has a learning curve and that Notion remains simpler for personal data storage, the combination of columns and explicit page subpages shifts Coda toward stronger team workflows. The emphasis is on consistency: buttons, structured pages, and dashboards help enforce a shared way of working, which is often hard to achieve in group settings. For teams managing lots of task details—project lists, action items, and recurring meetings—these two editor upgrades are positioned as the turning point that makes Coda feel more workable for real operations.

Cornell Notes

Coda’s editor update introduces two features that directly improve how teams organize and review information: true side-by-side columns and explicit subpages. Columns make it easier to build dashboards where charts and metrics can sit next to each other for quick comparison. The subpage change fixes a prior mismatch with Notion-style workflows by letting a column be defined as a “page,” turning table entries into full pages rather than hidden, hard-to-explain behaviors. This enables repeatable templates—like meeting note pages created via buttons—and lets data flow back into overview tables so people can see assignments and key points without opening every page. The result is stronger consistency and at-a-glance reporting for group work, despite Coda’s learning curve.

Why do columns matter so much for dashboard-style work in Coda?

Columns enable horizontal layout, so charts and other components can be placed side by side. That makes comparisons faster—such as checking multiple project metrics in one view—because users can widen sections and arrange elements next to each other instead of stacking them vertically. In data-heavy applications, this turns Coda from a storage tool into something closer to an at-a-glance monitoring dashboard.

What was confusing about earlier “subpages” behavior, and what changed?

Earlier subpages weren’t as explicit as Notion’s database-record-as-page model. Some page-like behavior was tied to small UI actions inside tables, so other people might not realize that a field is meant to act like a structured long-text form or that a record can open into a full page. The update adds a clearer mechanism: defining a column as a “page,” which turns each cell into a full-fledged Coda page.

How does the new page-column approach help when explaining systems to other people?

When subpages are explicit, users can more easily understand that each table entry corresponds to a page with its own content. That reduces the “hidden feature” problem where someone sees a string or control and doesn’t know it represents a long text form field. With page columns, the structure is more visible and closer to how Notion users expect records to behave.

How can meeting notes be operationalized using these features?

A user can create a button that generates a new meeting note with default fields like dates, attending people, an agenda, and prefilled sections. Then, the overview can pull key information from inside each meeting note—such as assigned actions and key points—into a table. That means stakeholders can review status directly in the overview without opening every note.

What broader team use cases benefit beyond meeting notes?

Any workflow that involves many tasks with detailed fields can benefit—project lists, action tracking, and recurring task management. The combination of structured pages, buttons, and dashboard overviews supports consistent data entry and reporting, helping teams maintain the same working format across multiple contributors.

Review Questions

  1. How do side-by-side columns change the way dashboards can be laid out in Coda?
  2. What specific limitation of earlier subpages made them harder to explain compared with Notion?
  3. Describe one workflow (meeting notes or project lists) and explain how data can flow from subpages back into an overview table.

Key Points

  1. 1

    Coda’s updated editor now supports side-by-side columns, making horizontal dashboard layouts workable.

  2. 2

    Columns enable quicker comparisons by placing charts and metrics next to each other in an overview view.

  3. 3

    Subpages were previously less explicit, which caused confusion when other people tried to use the system.

  4. 4

    A new “page” column lets table entries become full-fledged pages, aligning more closely with Notion’s record-as-page expectations.

  5. 5

    Buttons can generate repeatable templates such as meeting notes with default fields and agendas.

  6. 6

    Data can be pulled from inside subpages back into overview tables so users can track assignments and key points without opening every page.

  7. 7

    The combination of columns, explicit page subpages, and structured workflows supports consistent team operations despite Coda’s learning curve.

Highlights

Columns finally work horizontally in Coda, unlocking dashboard layouts where charts sit side by side for fast comparison.
Defining a column as a “page” makes subpages explicit—reducing the confusion caused by earlier, more hidden page behavior.
Meeting notes can be templated with buttons and then summarized back into an overview table for at-a-glance action tracking.

Topics