# Command Mode
Source: https://runway-docs.cfo.ai/ai/command-mode

Use Command Mode to build and update Runway work by describing what you want.

Ari, Runway's AI assistant, can answer questions, inspect your model, and make changes when you describe what you want. Use Ari when you want to build pages, formulas, SQL, charts, scenarios, or multi-step modeling changes with natural language.

## The Ari chat

Open Ari from the bottom-right button labeled **Open ARI chat**. The panel is titled **Ari**, and the input placeholder is **Ask anything**.

<Steps>
  <Step title="Open Ari">
    Click the Ari button in the bottom-right corner of Runway.
  </Step>

  <Step title="Ask a question or request a change">
    Type in **Ask anything**. Ari supports multiturn conversations, so you can refine the request after the first response.
  </Step>

  <Step title="Control the response">
    While Ari streams a response, the send button becomes **Stop generation**. Press **Esc** to close the panel, or press **Shift+Enter** to add a new line in your prompt.
  </Step>
</Steps>

The chat header includes **New conversation** and **Move to floating chat panel** or **Move to sidebar**.

## Command Mode

Command Mode is the Option-click (Alt-click on Windows) surface for write actions. Use it when you want Ari to change the object you are pointing at instead of chatting first.

| Where you Option-click (Alt-click on Windows) | Prompt placeholder                  | Accept action                  | Discard action                     |
| --------------------------------------------- | ----------------------------------- | ------------------------------ | ---------------------------------- |
| Formula cell                                  | **Describe the formula...**         | **Save Changes**               | **Discard Changes**                |
| SQL editor                                    | **Describe the SQL query...**       | **Accept**                     | **Reject**                         |
| Chart block                                   | **Describe chart configuration...** | Use the generated chart change | Discard the generated chart change |

## What Ari can build

Ari can create and update databases, drivers, submodels, pages, scenarios, text blocks, driver grid blocks, chart blocks, SQL, and multi-step plans. When Ari works through a plan, Runway shows a **My plan** progress panel with a progress counter, todo status icons, and expandable subtasks.

## Good prompts

* "Create a chart of revenue by region for this year."
* "Write a forecast formula for net new ARR based on new customers and average contract value."
* "Create a scenario for the downside hiring plan and add a page that compares it to Main."

<Note>
  Ari and Command Mode are currently available to org Admins and Owners.
</Note>

## FAQ

<Accordion title="Is Ari the same thing as Command Mode?">
  Ari is the assistant. Command Mode is the Option-click (Alt-click on Windows) write surface that lets Ari change a specific formula, SQL editor, or chart.
</Accordion>

<Accordion title="Can I stop Ari while it is writing?">
  Yes. While a response is streaming, click **Stop generation**.
</Accordion>

<Accordion title="Can Ari work through multiple steps?">
  Yes. Ari can create a multi-step plan and show progress in the **My plan** panel while it works.
</Accordion>

## What's next

* [Explain Mode](/ai/explain-mode)
* [Connecting AI tools](/ai/connecting-ai-tools)
* [Formulas syntax](/concepts/formulas/formulas-syntax)


# Connecting AI tools (MCP)
Source: https://runway-docs.cfo.ai/ai/connecting-ai-tools

Connect Claude and other AI tools to Runway through MCP.

Runway exposes a hosted MCP endpoint so Claude and other MCP-capable AI tools can read from your Runway model. Use it when you want an external assistant to search your model, read pages, inspect drivers, or calculate values without giving it write access.

## Setup

<Steps>
  <Step title="Add the remote MCP server">
    In your AI client, add `https://runway-api.cfo.ai/mcp` as a remote MCP server.
  </Step>

  <Step title="Sign in to Runway">
    Your browser opens the Runway login flow through OAuth.
  </Step>

  <Step title="Approve access">
    Approve the connection. The client receives OAuth tokens, so there are no API keys to manage.
  </Step>
</Steps>

## Claude setup example

<Steps>
  <Step title="Open Claude settings">
    In Claude, open the settings area.
  </Step>

  <Step title="Open connectors">
    Go to the connectors area.
  </Step>

  <Step title="Add a custom connector">
    Add a custom connector with `https://runway-api.cfo.ai/mcp` as the URL.
  </Step>
</Steps>

## What the connection can do

All hosted MCP tools are read-only.

| Capability                | Tool                          | Description                                                              |
| ------------------------- | ----------------------------- | ------------------------------------------------------------------------ |
| List orgs                 | `runway_list_accessible_orgs` | List the Runway orgs accessible to the current authenticated user.       |
| Search                    | `runway_search`               | Search a Runway org for pages, drivers, scenarios, and related entities. |
| Read pages                | `runway_read_page`            | Read a Runway page and its visible contents.                             |
| Read drivers and formulas | `runway_get_driver`           | Read metadata and formulas for a Runway driver.                          |
| Calculate values          | `runway_get_driver_values`    | Calculate driver values for one or more scenarios and month keys.        |
| List scenarios            | `runway_list_scenarios`       | List the published scenarios in a Runway org.                            |

## Limits and security

* The MCP endpoint is read-only.
* Access is available to Admin and above.
* The rate limit is 60 calls per minute per user, tool, and org.
* Authentication uses OAuth. You do not need to create or store API keys.

## FAQ

<Accordion title="Can an AI tool change my Runway model through MCP?">
  No. The hosted MCP tools are read-only.
</Accordion>

<Accordion title="Do I need a Runway API key?">
  No. The connection uses OAuth through your browser login.
</Accordion>

<Accordion title="Who can connect an external AI tool?">
  Hosted MCP access is available to Admin and above.
</Accordion>

## What's next

* [Command Mode](/ai/command-mode)
* [Export API](/integrations/export-api)
* [Roles and access](/reference/roles-and-access)


# Data and privacy
Source: https://runway-docs.cfo.ai/ai/data-and-privacy

How Ari handles your data, model providers, and retention.

Ari uses a combination of APIs from **OpenAI** and **Anthropic**. Both providers operate under commercial API terms that explicitly prohibit using customer data for model training. **Runway does not use your data for training either.**

## Retention

API inputs and outputs are temporarily retained by our model providers, then automatically deleted:

| Provider  | Retention     |
| --------- | ------------- |
| OpenAI    | Up to 30 days |
| Anthropic | Up to 7 days  |

## When Ari runs

Ari only runs when you **explicitly trigger it**. There's no background processing or passive data collection.


# Explain Mode
Source: https://runway-docs.cfo.ai/ai/explain-mode

Use Explain Mode to understand why a number appears in your Runway model.

Explain Mode lets you ask Runway why a value, formula, chart, query, or page looks the way it does. Use it when you want to understand the model behind a number without tracing every dependency by hand.

## How to use Explain Mode

<Steps>
  <Step title="Hold Option">
    Hold **Option** on Mac or **Alt** on Windows while you are anywhere in Runway.
  </Step>

  <Step title="Point at something explainable">
    Hover over or click a highlighted value, row, chart, formula, database cell, SQL editor, or page item.
  </Step>

  <Step title="Read the explanation">
    Runway opens an anchored AI explanation dialog and streams the answer as it works.
  </Step>
</Steps>

## What you can explain

### Driver values

Explain a driver row or value cell to see the inputs, formula logic, and period context behind the number. Explain Mode also handles rollup periods such as YTD and QTD, including month-by-month trend context.

### Charts

Explain a driver chart to understand what the chart is showing and how the underlying driver values contribute to the view.

### Formulas

Explain a formula cell to understand how its references, date ranges, actuals logic, and forecast logic work together.

### Variance in BvA comparisons

Explain Mode can analyze variance in BvA comparisons, including contribution percentages from the dependency tree.

### Database cells and columns

Use Explain Mode on database table cells and column headers to understand the source data, formulas, and column meaning.

### SQL queries

Use Explain Mode in a SQL query editor to open an explanation titled **Explain SQL Query**.

### Whole pages

Use Explain Mode on page titles and navigation items to summarize what a page contains and how it is structured.

## The dialog

The explanation streams into a dialog with collapsible thinking steps. From the header, you can start **New conversation**, move the dialog to **Move to floating chat panel** or **Move to sidebar**, or use **Minimize** and **Close**.

<Note>
  Explain Mode is currently available to org Admins and Owners.
</Note>

## FAQ

<Accordion title="Why doesn't anything highlight when I hold Option?">
  Explain Mode only responds on explainable product surfaces. In grids, real data rows respond, while headers and summary rows may not.
</Accordion>

<Accordion title="Can Explain Mode explain rolled-up periods?">
  Yes. It can explain rollups such as YTD, QTD, quarter-to-last-close, half-year-to-last-close, and year-to-last-close.
</Accordion>

<Accordion title="Can every user in my workspace use Explain Mode?">
  Explain Mode is currently available to org Admins and Owners.
</Accordion>

## What's next

* [Command Mode](/ai/command-mode)
* [Driver details pane](/concepts/drivers/driver-details-pane)
* [Budget vs. actuals](/guides/modeling/bva)


# Databases basics
Source: https://runway-docs.cfo.ai/concepts/databases/databases-basics

Databases store raw and modeled business data in rows, then make that data available to drivers, formulas, pages, and reports.

Databases are where source data becomes structured model data. Use a database when you need rows of real things, such as transactions, employees, deals, vendors, or assumptions, that can be segmented, rolled up, and referenced by drivers.

## What is a database?

When you connect an integration, your data flows into a database. You can then create additional databases that pull from the original database and aggregate the data at different levels. For example, if you import GL data with vendor-level details from QuickBooks, NetSuite, or Xero, you can build another database that rolls it up by department or class.

## Creating a database

<Steps>
  <Step title="Create the database">
    Click the **+** button next to a section or page in the sidebar.
  </Step>

  <Step title="Choose the type">
    Select **Database** and give it a clear name, icon, or emoji.

    <Frame>
      <img alt="Sidebar creation menu with Database selected" />
    </Frame>
  </Step>
</Steps>

## Configuring a database

After creating a database, configure the source, drivers, and segmentation that determine its grain.

<Steps>
  <Step title="Open configuration">
    Click the **configuration** header to expand it.
  </Step>

  <Step title="Choose the data source">
    Select an existing integration query or another database.
  </Step>

  <Step title="Choose drivers">
    Choose the key metrics or dates you want to track as time series data.
  </Step>

  <Step title="Choose dimensions">
    Select the dimensions to segment your data. Segmentation determines the database's granularity.
  </Step>

  <Step title="Add other columns">
    Add useful metadata from the data source under **Other columns**.
  </Step>
</Steps>

For example, if you are pulling in GL data at the most granular level, you might select **Amount** as the driver, use **Account Name**, **Class**, and **Vendor** as dimensions, and include **Account Type** under **Other columns**.

<Frame>
  <img alt="Database configuration panel with data source, drivers, and dimensions" />
</Frame>

The dimensions you use to segment your data appear alongside the driver name across the app, including in tables and charts. To improve readability, use only the dimensions needed to define the database's grain. Add extra metadata under **Other columns** instead.

<Frame>
  <img alt="Dimension pills displayed beside a database-backed driver" />
</Frame>

<Tip>
  To inspect the structure of your source data before confirming the database, use the preview table.
</Tip>

<Frame>
  <img alt="Database configuration preview table" />
</Frame>

<Tip>
  To limit the database to a subset of source data, apply a filter within the database configuration.
</Tip>

<Frame>
  <img alt="Database configuration filter panel" />
</Frame>

## Adding a column

To create a new column, click the **+** button at the far right of the database. You can add:

* **Number driver:** Calculated numeric values. Drivers store time series data, so values can vary by month.
* **Date driver:** Date values that can also vary over time.
* **Dimension:** A predefined list of values that categorizes rows, such as Vendor, Location, or Department.
* **Lookup:** A column that populates a dimension based on data from another database, similar to `VLOOKUP()`.

<Note>
  For HRIS databases, follow the separate [HRIS database column flow](/concepts/databases/hris-databases#adding-columns-to-hris-databases).
</Note>

<Frame>
  <img alt="Database add-column menu with driver and dimension options" />
</Frame>

## Show a column as time series

Drivers store time series data. In database tables, each driver column is usually displayed as a single value for readability, but you can expand one driver column to show its monthly values.

<Steps>
  <Step title="Open the column menu">
    Click the driver column name in the database header.
  </Step>

  <Step title="Show time series">
    Select **Show as time series**. The column expands on the far right after the other columns.

    <Frame>
      <img alt="Database column expanded as a time series" />
    </Frame>
  </Step>
</Steps>

<Note>
  If you show a different driver column as a time series, it replaces the currently expanded one.
</Note>

By default, each row shows forecast formula, actuals formula, and time series data for the selected date range. You can hide formula columns from column menus, from **Customize** > **Properties**, or with the shortcuts listed in [Keyboard shortcuts](/get-started/keyboard-shortcuts).

<Frame>
  <img alt="Database column menu with Hide in blocks selected" />
</Frame>

<Frame>
  <img alt="Database properties panel with column visibility controls" />
</Frame>

To return the driver column to a single value, click the column name again and select **Show as value**.

<Frame>
  <img alt="Database column menu showing Show as value" />
</Frame>

## Show all columns as time series

Instead of expanding only one driver column, you can display all driver columns as time series.

<Steps>
  <Step title="Open customize">
    Click **Customize** in the top-right corner.
  </Step>

  <Step title="Choose time series">
    Select **Display as**, then choose **Time series**.

    <Frame>
      <img alt="Database switched to time series display" />
    </Frame>
  </Step>
</Steps>

When you switch to this view, each former row becomes a section, and dimensions and drivers that were shown as columns become rows.

<Frame>
  <img alt="Database time series orientation with drivers as rows" />
</Frame>

## Show and hide columns

For a compact view, hide columns that are not always relevant and show them only when needed.

<Steps>
  <Step title="Use the column header">
    Click the column name in the database header and select **Hide in block**.
  </Step>

  <Step title="Use customize">
    Or click **Customize**, open **Properties**, and toggle columns with the eye icon.

    <Frame>
      <img alt="Database column hidden from a block" />
    </Frame>
  </Step>
</Steps>

## Adding a row

If you need to manually add a row to a database, click **+ Add item**. After adding the row, set values for the dimensions used in **Segment by**.

<Frame>
  <img alt="Database with a manually added row" />
</Frame>

<Note>
  Segmentation determines the granularity of your database. Each row should have a unique combination of dimension values. If a row does not have a unique combination, Runway shows a warning because that row is linked to other rows with the same segmentation.
</Note>

For HRIS databases, follow the [HRIS database row flow](/concepts/databases/hris-databases).

## Deleting a column

The deletion flow depends on how the column was added.

<Steps>
  <Step title="Remove configured columns from configuration">
    For columns coming from database configuration, remove the column from the relevant section in configuration: Driver, Segment by, or Other columns. This prevents it from reappearing after the next integration sync or configuration refresh.

    <Frame>
      <img alt="Database configuration with a column removed from configuration" />
    </Frame>
  </Step>

  <Step title="Delete manually added columns from the column header">
    For manually added columns, click the column header and select **Delete property**. If the column is used elsewhere in your model, Runway asks you to confirm because deleting it can cause reference errors.

    <Frame>
      <img alt="Database column menu showing Delete property" />
    </Frame>
  </Step>
</Steps>

## Deleting a row

To delete a row from a database, right-click the row and select **Delete row**.

<Warning>
  Deleting a row removes it from the database, but it does not delete the drivers connected to that row. Any formulas relying on those drivers remain unchanged, and the drivers still appear in your **Unlisted Drivers** page.
</Warning>

To fully delete a driver and eliminate its impact on formulas, delete it from **Unlisted Drivers**.

<Frame>
  <img alt="Unlisted Drivers page showing drivers not present on a page or model" />
</Frame>

## What's next

* [Formulas in databases](/concepts/databases/formulas-in-databases)
* [Segmenting drivers](/concepts/dimensions/segmenting-drivers)
* [Database block](/concepts/pages/database-block)


# Filtering, sorting & grouping
Source: https://runway-docs.cfo.ai/concepts/databases/filtering-sorting-grouping

When working with a database in Runway, you often need to adjust how data is displayed to focus on what matters most. Whether you're filtering specific rows, sorting for better readability, grouping relevant items, or adjusting the date range, Runway provides powerful tools to help you tailor your view.

## Filtering

Filtering is useful when modifying or debugging database data, allowing you to focus on a specific subset of rows. It also helps when adding a database block to a page to share with your team without exposing the entire database. For example, you can filter a GL database by **department**, so each department head only sees the vendors they are responsible for.

To apply a filter, click on the **Add filter** pill at the top of a database, then select the **dimension** or **driver** you want to filter by.

* **Filtering by a dimension** allows you to use operators like **is one of, is none of, is empty,** and **is not empty.** When using **is one of** or **is none of,** you can select one, multiple, or all dimension values.

* **Filtering by a number driver** supports operators like **is, is not, greater than, greater or equal,** and more. After selecting an operator, you can enter the comparison value in a free-text field.

* **Filtering by a date driver** supports operators like **is, is not, is after, is on or after,** and more. After selecting the operator, you can choose from a wide range of date options, such as **this month, last month, custom months ago,** or even reference another driver to dynamically set the number of months.

<img alt="Filters" />

Since drivers store time-series data that can change from month to month, you might wonder—**which month's data does Runway use when applying a filter?** By default, driver filters evaluate data based on **this month’s** values. You can change this to filter based on **last close month** or a specific custom month.

To adjust this, click on the **As of** pill at the top of a database, set the **Time period** to **As of,** and modify the date.

<img alt="As Of" />

<Note>
  When you add multiple filters, they are **ANDed** together, meaning only rows that meet all conditions will be shown.
</Note>

## Sorting

You can sort your database data based on one or multiple **dimensions** or **drivers**.

<img alt="Sorting" />

When sorting by a **dimension**, you can choose:

* **Alphabetically / Reverse Alphabetically**

* **Numerically** – Useful when dimension values contain numbers. Even if a number is part of a text string, Runway isolates it and sorts accordingly.

* **Manual** – Allows you to manually reorder rows.

When sorting by a **number driver**, you can choose **ascending** or **descending** order. When sorting by a **date driver**, you can sort from **earliest to latest** or **latest to earliest**.

Similar to filtering, sorting by a driver evaluates data based on **this month’s** values. You can change this to sort based on **last close month** or a specific custom month by adjusting the **As of** pill.

## Group by

For better readability, you can **group** your database rows by any of your dimensions. Click the **Group by** pill at the top of the database (next to filter and sort), then select the dimension you want to group by.

Similar to filtering and sorting, grouping by a driver evaluates data based on **this month's** values. You can change this to group based on **last close month** or a specific custom month by selecting the date option in the group by menu.

<img alt="Group By" />

## Date range

Changing the date range for a database primarily affects **drivers**, as they hold data that can change over time and be displayed as a time series. **Dimensions**, on the other hand, are static and remain unaffected by date range changes.

When displaying **one or all drivers as a time series**, each **month** within the selected date range is shown as a separate column.

To change the date range, click on the “**Date range”** pill at the top of the database and select the **start** and **end** months.

<img alt="Date Range" />

When displaying a driver column as a value, the values shown in that column are also defined by the date range. You will see Value of first month in the date range → Value of last month in the date range. If the first and last values are the same, only that single value is displayed without the → annotation.

<img alt="Rollup" />


# Formulas in databases
Source: https://runway-docs.cfo.ai/concepts/databases/formulas-in-databases

This article covers how to manage driver formulas in databases to support scalable, dimensional modeling in Runway. 

For guidance on mapping values using dimensions, see [Lookups](/guides/modeling/lookups).

## Default formulas

* Setting default formulas across a column can save a lot of time—both when you have many drivers that should follow the same logic, **and** when new segments are added to the database. Any new segment will automatically inherit the default formula unless it’s explicitly overridden.
* In databases, each driver column can have a default formula, and any individual row (i.e., specific segmented driver) can override it. To revert to the default, just backspace or clear the custom formula.
* Inherited formulas are shown in a lighter style to indicate they’re coming from the default.

<video />

## Formula inheritance

To make modeling at scale simple—while keeping it easy to override when needed—Runway applies **smart defaults** to fill in missing formulas.

When editing a formula, you can **hover over the formula editor** to see where the value is being inherited from.

Runway follows a clear set of rules to determine how formulas are inherited and overridden.

### **Actuals formula** inheritance hierarchy

Runway applies the actuals formula using the following order of precedence:

1. An **explicitly set actuals formula** for the driver
2. A **default actuals formula** set at the column level in the database
3. If no actuals formula is available, the driver falls back to its **forecast formula**

### Forecast formula inheritance hierarchy

Similarly, forecast formulas follow this order of precedence:

1. An **explicitly set forecast formula** for the driver
2. A **default forecast formula** set at the column level in the database
3. If none is set, Runway uses the field's value last month, propagated forward. In the editor, this appears as the field's own name with the **Last month** time period.

For example, if only a forecast formula is set at the column level, every driver in that column will automatically inherit that formula—unless an override is applied.

## Dynamic formulas using *This Segment*

In highly dimensional models, when you want to apply similar logic across many segments (like forecasting product usage or modeling revenue per customer), you can use ***This Segment*** to write formulas that scale.

* ***This Segment*** refers to **other data that shares some or all of the same dimensional attributes** as the driver you’re writing the formula for.
* It allows you to write a **single formula** that dynamically adjusts based on the segment it’s applied to—helping you avoid repetitive formulas and reduce the chance of errors.
* While most commonly used within the same database, ***This Segment*** also works **across different databases**.
* You can also use **dimension filters** inside *This Segment* to fine-tune the match—for example, matching on just one shared dimension if that’s all that’s needed.

Let’s walk through some common use cases where *This Segment* helps scale your modeling logic and keep things simple.

<Tip>
  When chaining formulas together in databases, the **Timeseries view** is a great way to see how logic flows across multiple drivers. You’ll be able to view all default formulas side by side, and edit them directly by clicking the **ƒ** icon for each driver to see how changes propagate.

  You can switch to this view via: **Customize → View as → Timeseries**.\
  \\

  <img alt="View Db As Timeseries Exaplined" />
</Tip>

### Example: Dynamic default formula using *This Segment*

In this example, we use the *This Segment* to populate a default formula that applies consistent logic across all segments in the database. Below is a video and diagram to help illustrate how it works.

<video />

<img alt="Dim DB Overview Diagram" />

### Example: Dynamic filters using dimensions

Sometimes, you may want to filter based on partial match with a segment—for example, matching on a single dimension rather than all of them. With *This Segment*, you can apply dynamic filters across **all dimensions** or a **subset of them**, directly from the filter menu.

Let’s walk through an example: you want to calculate what percentage of each product’s usage is consumed by each customer.

<video />

In the filter menu:

* If you want to match across **all** the dimensions in the segment (e.g. match on Customer Name + Product), you can use the **Segment** filter.
* To apply the dynamic filters for specific dimensions, you can select the relevant dimension and then use the **This \<dimension name>** option.

When choosing what to filter:

* Selecting a **formula pill with the database name and icon** lets you filter on **any column** in that database.
* Selecting a **formula pill with just the driver name** limits you to filtering on **columns the driver is segmented by.**

<img alt="Partial This Segment Filter" />

### Example: Dynamic filters using driver values

**Numeric drivers** There’s one more powerful use case for *This Segment*—using it to dynamically match on **driver values**, not just dimensions. This allows you to reference a value from one driver based on the value of another, similar to `VLOOKUP()` in Excel—but more robust.

Let’s walk through an example. You want to charge customers different unit prices based on their usage tier thresholds.

Imagine you have a database of **usage tiers** with associated **unit prices**, and you're trying to calculate how much to charge each customer.

<img alt="Dynamic Filters Overview" />

To perform this match, we can simply apply a formula that multiplies: `each customers # transactions` \* `unit price for their usage tier`

You can then use *This Segment* in the filter menu to dynamically select the correct unit price for each customer based on their usage level.

<video />

**Date drivers** You can also use *This Segment* to dynamically filter based on **date driver values** — a powerful technique often used in cohort or revenue recognition models.

When filtering a database by a date column, you'll see the option to use **\<date driver value>** as the filter value. This allows you to reference dates from your model—such as contract start dates, signup dates, or feature release dates.

To apply this dynamically for each segment, use *This Segment* when selecting the date driver. That way, each segment uses **its own corresponding date** to filter the data.

<video />


# Legacy HRIS databases
Source: https://runway-docs.cfo.ai/concepts/databases/hris-databases

HRIS data is essential for modeling personnel-related expenses—often the largest cost for most businesses. In Runway, HRIS data modeled before September 2025 behaves differently from other data sources, particularly when using the Employees database. This guide outlines key distinctions you should know. 

<Info>
  **Why are these differences present?**

  These differences arise due to our long-standing integrations with HRIS data partners. If you are experiencing issues or limitations with your legacy HRIS database, please contact the Runway crew to begin your migration. We're standing by!
</Info>

You can also read our step-by-step guide on headcount modeling [here](/guides/modeling/headcount-planning).

## Rows represent an employee defined by their name

In typical Runway databases, [**segmentation determines the granularity of your database**](/concepts/databases/databases-basics#adding-a-row). Each row has a **unique combination** of dimension values.

In HRIS databases, each row represents a single **employee, identified by their name.**

<img alt="Hris Rows" />

## Columns are fields, not drivers

Unlike standard databases in Runway, HRIS columns are **fields**, not drivers.

As a result, reusing HRIS data elsewhere—whether in formulas or on pages—works a bit differently.

### Using HRIS data in formulas

The HRIS database stores data such as salaries, bonuses, and benefits for each employee. To use this data in calculations—for example, to sum salaries across departments—you'll typically want to aggregate field columns into a standard driver.

Here's how:

1. Create a regular driver in a driver table block (on a [page](/concepts/pages/drivers-table-block) or in a [model](/concepts/models/models-basics)).
2. In the formula editor, search for and reference the field column from the Employees database. You can search by the field column name, but not by the employee name or any of its attributes.

   <img alt="Search For Field In Formula" />
3. Add an aggregator (e.g. sum) and use filters to define which employees to include.

   <img alt="Fields Filters Informula" />

### Surfacing HRIS data on a page

When sharing or collaborating on HRIS data, you typically don't need to display the entire Employees database. Instead, you have a couple of focused options:

1. Add the calculated drivers (as described in the previous section) to a [driver table block](/concepts/pages/drivers-table-block) or a [chart block](/concepts/pages/charts-block) to show totals or trends.
2. Include a [filtered view of the Employees database](/concepts/pages/database-block) to highlight specific roles, departments, or planned hires.

## Adding rows to HRIS databases

You can manually add rows to HRIS databases to model future employees or anticipated hires. Keep these important points in mind:

* Each row inherits the default formula set for field columns, and **these formulas cannot be overridden for individual rows.**
* When actual employee data is later imported from your HRIS system, **it won't automatically reconcile with manually added placeholder employees**. You'll need to manage this reconciliation.

## Adding columns to HRIS databases

You can add new field columns to include additional logic or metadata (e.g. currency conversions, benefits, taxes):

* Click the **+** button >**Fields** > choose a field type (e.g. Number Field).
* Supported column types include:
  * Number Fields
  * Date Fields
  * Text Fields

<Warning>
  Be sure to select column types nested under the **Fields** option, not the regular driver column types.
</Warning>

<img alt="Hris Columns" />

## Setting formulas in HRIS databases

Each column in the HRIS database can include a formula that applies to all rows.

* Formulas can't be overridden at the row level.
* These formulas use the dynamic "This" reference pattern to refer to values in the same row. This enables logic like `Total Salary = Base Salary * 1.25` to apply uniformly across employees.
* References to segments in **other** databases are not currently supported. HRIS formulas can only reference columns within the same database.

<img alt="Hris Column Formulas" />

## Start date

Every employee row includes a **Start date** field that acts as a switch for time-based calculations:

* Before the start date, any formulas for the row's fields evaluate to `NULL`.
* After the start date, formulas evaluate as normal.

This behavior works implicitly, similar to wrapping every field's formula in a condition like:

```
if(thisMonth() < this.Start Date, NULL, [column's formula])
```

Start Date also defines which employees show up on your Plans timeline. [You can read more about how Plans work with employee start dates here.](/concepts/plans#connecting-an-employee%E2%80%99s-start-date-to-a-plan)


# Rename, export & delete
Source: https://runway-docs.cfo.ai/concepts/databases/rename-export-delete

As you work with databases in Runway, you may need to rename, export, or delete them to keep your workspace organized and up to date. 

## Renaming a database

There are a couple of ways to rename a database:

**From the sidebar** – Click the **•••** (more options) icon next to the database name in the sidebar, then select **Rename.** You can modify the name and click the icon to change it.

<img alt="Rename Sidebar" />

**From the database page** – Navigate to the database, then click on its name at the top to edit it. You can also click the icon to change it.

<img alt="Rename In Page" />

## Exporting a database

To export a database, click the **•••** (more options) icon next to its name in the sidebar, then select **Export to CSV.**

<img alt="Export Sidebar" />

Alternatively, navigate to the database, click the **More** icon in the top-right, and select **Export to CSV.**

<img alt="Export In Page" />

The exported CSV will match the data as it appears on your screen at the time of export. Any applied filters, date ranges, or sorting will be preserved. Additionally, all driver columns will be shown as values, except for the one (if any) that is displayed as a time series.

## Deleting a database

To delete a database, click the **•••** (more options) icon next to its name in the sidebar or the **More** icon in the top-right corner of the database, then select **Delete database.** If any **drivers** from this database are used elsewhere in your model, you will be asked to confirm the action, as deleting the database could cause errors in places where it is referenced.

<img alt="Delete" />


# Dimensions basics
Source: https://runway-docs.cfo.ai/concepts/dimensions/dimensions-basics

Dimensions categorize data in Runway so drivers and databases can be segmented by meaningful business attributes.

Dimensions are categorical values such as Department, Region, Account, Product, or Role. Use them when you need to slice drivers and databases by the same business attributes across your model.

## Integration-powered dimensions

When you create a database using an [integration](/integrations/intro-to-integrations), Runway can create dimensions from structured source data. For example:

* A General Ledger can create dimensions such as GL Account Name.
* An HRIS source can create dimensions such as Team, Department, Title, Payment Currency, and Office.
* A CRM source can create dimensions such as Pipeline Stage or Account Owner.

Integration-created dimensions stay in sync as the source system changes. You can reuse them throughout your model.

## Manually creating dimensions in databases

<Steps>
  <Step title="Add a dimension column">
    In a database, click the **+** button at the far right and select **Dimension**.

    <Frame>
      <img alt="Database add-column menu with Dimension selected" />
    </Frame>
  </Step>

  <Step title="Reuse or create a dimension">
    Search for an existing dimension to reuse, or type a new name and press Enter to create one.

    <Frame>
      <img alt="Dimension search for reusing an existing dimension" />
    </Frame>

    <Frame>
      <img alt="Creating a new dimension column from the database menu" />
    </Frame>
  </Step>

  <Step title="Populate values">
    Set the dimension value for each row, or use [lookup logic](/guides/modeling/lookups) to populate values from another database.

    <video />
  </Step>
</Steps>

This is useful for enriching data with metadata such as Region, Initiative, or Product Line when those dimensions are not coming from a connected system.

## Segmenting drivers with dimensions

You can also segment an unsegmented driver in a model. The full workflow lives in [Segmenting drivers](/concepts/dimensions/segmenting-drivers#segmenting-drivers-in-a-model), which is the canonical place for step-by-step segmenting instructions.

## Managing dimensions

Use the dimensions manager for dimension lists that are shared across multiple databases.

<Steps>
  <Step title="Open from a database">
    From a dimension column in a database, click the column header and select **Manage dimension**.

    <Frame>
      <img alt="Database dimension column menu with Manage dimension" />
    </Frame>
  </Step>

  <Step title="Or open from settings">
    Go to **Settings** > **Dimensions** from your user menu.
  </Step>

  <Step title="Add dimensions or values">
    Click **+ Add Dimension** to create a new global dimension, or click **+ Add \[Attribute]** to add a value to an existing dimension.

    <Frame>
      <img alt="Dimensions settings panel with dimension values" />
    </Frame>
  </Step>
</Steps>

### Viewing dimension sources

When viewing a dimension in the dimensions panel, you can see where it was sourced from. Dimensions created from integrations display source information.

### Bulk deleting dimension attributes

Select multiple attributes, then press **Backspace** to delete them. See [Keyboard shortcuts](/get-started/keyboard-shortcuts) for more editing shortcuts.

## What's next

* [Segmenting drivers](/concepts/dimensions/segmenting-drivers)
* [Manual segments](/concepts/dimensions/manual-segments)
* [Lookups](/guides/modeling/lookups)


# Manual segments
Source: https://runway-docs.cfo.ai/concepts/dimensions/manual-segments

Create and manage manual dimension segments when your model needs structure that does not come from a connected data source.

Manual segments let you segment drivers by a dimension you define by hand, without connecting a data source. Use them for planning structures such as departments, regions, products, or custom groups that you want to manage directly in Runway.

## Add manual segments to a database

Manual segments live in the database configuration editor and are available for databases without a data source.

<Steps>
  <Step title="Open the database configuration editor">
    Open the database you want to segment and open its configuration editor.
  </Step>

  <Step title="Open Segment by">
    Find the **Segment by** section. New databases without segments show **No segments**.
  </Step>

  <Step title="Add a segment">
    Click **Add segment**.
  </Step>

  <Step title="Find or create a segment">
    Use the **Find or create segment** search field.
  </Step>

  <Step title="Choose an existing dimension or create one">
    Select an existing dimension and choose **Add to Database**, or type a new name and choose **Create segment**.
  </Step>
</Steps>

Existing dimensions can show **Add to Database** or **Used by Database** depending on whether the database already uses them.

## How manual segments behave

Hand-made segments key the database the same way integration-derived segments do. After you add the segment, driver columns in the database can use the segment values for formulas, filtering, and dimensional driver references.

## Remove a segment

<Steps>
  <Step title="Open Segment by">
    Open the database configuration editor and find **Segment by**.
  </Step>

  <Step title="Remove the segment">
    Remove the segment from the same panel where it was added.
  </Step>

  <Step title="Review dependent work">
    Check formulas and driver references that used the removed segment.
  </Step>
</Steps>

## FAQ

<Accordion title="Do manual segments require an integration?">
  No. Manual segments are for databases without a data source.
</Accordion>

<Accordion title="Are manual segments different from integration-derived segments?">
  They are created by hand, but they key the database the same way integration-derived segment keys do.
</Accordion>

<Accordion title="Can I create a new dimension while segmenting a database?">
  Yes. Type a new name in **Find or create segment**, then choose **Create segment**.
</Accordion>

## What's next

* [Segmenting drivers](/concepts/dimensions/segmenting-drivers)
* [Databases basics](/concepts/databases/databases-basics)
* [Dimensions basics](/concepts/dimensions/dimensions-basics)


# Segmenting drivers
Source: https://runway-docs.cfo.ai/concepts/dimensions/segmenting-drivers

Segment drivers with dimensions so one metric can be modeled by department, region, account, or another business attribute.

Segmenting drivers lets one driver represent many dimension values. Use it when a single metric, such as Revenue or Headcount, should be modeled by Department, Region, Account, Product, or another dimension.

## Why segment drivers?

### Easier and scalable modeling

Without dimensions, modeling **Growth Rate by Region** might require separate drivers such as `Growth Rate - US` and `Growth Rate - EMEA`. That naming pattern gets hard to maintain, and totals must reference each driver manually.

<Frame>
  <img alt="Separate unsegmented growth rate drivers by region" />
</Frame>

With dimensions, a single **Growth Rate** driver can be segmented by **Region**. You can write one formula that applies to each region using [This Segment](/concepts/databases/formulas-in-databases#dynamic-formulas-using-this-segment), and rollups stay maintained as dimension values are added.

<Frame>
  <img alt="Single growth rate driver segmented by region" />
</Frame>

### Roll up and drill into data

Dimensions make it easier to model at different levels of granularity.

For example, a database with **Revenue** segmented by **Region** and **City** has one driver per region-city combination.

<Frame>
  <img alt="Revenue segmented by region and city" />
</Frame>

To view Revenue rolled up by Region, create a rolled-up database:

<Steps>
  <Step title="Open or create the rollup database">
    Open the target database where the rolled-up data should live, or [create a database](/concepts/databases/databases-basics#creating-a-database).
  </Step>

  <Step title="Open configuration">
    Click **Edit** to open [database configuration](/concepts/databases/databases-basics#configuring-a-database).
  </Step>

  <Step title="Add the source">
    Add the source database that is segmented by Region and City.
  </Step>

  <Step title="Choose drivers">
    Choose the drivers you want to aggregate, such as Revenue.
  </Step>

  <Step title="Choose the rollup segment">
    Under **Segment by**, select the higher-level dimension, such as Region.
  </Step>

  <Step title="Confirm">
    Click **Confirm**.

    <Frame>
      <img alt="Creating a rollup database from a more granular segmented database" />
    </Frame>
  </Step>
</Steps>

The Revenue driver is now available at both granularities: Region x City and Region.

<Frame>
  <img alt="Driver search showing revenue at multiple granularities" />
</Frame>

You can [drill in](/concepts/drivers/drill-ins) when you want detail and roll up when you want the big picture.

<Frame>
  <img alt="Rolled up revenue with drill-in detail" />
</Frame>

You can create similar hierarchies from other columns, not only the dimensions used in database configuration.

## How to segment drivers

### Segmenting drivers in a database

When [configuring a database](/concepts/databases/databases-basics#configuring-a-database), the **Segment by** field determines how the drivers in that database are broken down.

<Frame>
  <img alt="Database configuration Segment by field" />
</Frame>

For example, a granular GL database might segment by `Account Name`, `Class`, and `Vendor`. A later rollup database might source from that granular database but segment only by `Class`.

### Segmenting drivers in a model

You can segment an unsegmented driver in a [model](/concepts/models/models-basics):

<Steps>
  <Step title="Open the driver menu">
    Click the menu next to the driver name.
  </Step>

  <Step title="Add dimension">
    Hover over **Dimensions**, then select **Add dimension**.

    <Frame>
      <img alt="Driver menu with Add dimension action" />
    </Frame>
  </Step>

  <Step title="Choose or create the dimension">
    Choose an existing dimension, or type a new name and press Enter to create one.

    <Frame>
      <img alt="Creating a dimension from a driver menu" />
    </Frame>
  </Step>

  <Step title="Define values">
    Define the dimension values from the submenu.

    <Frame>
      <img alt="Segmented driver values created from a dimension" />
    </Frame>
  </Step>
</Steps>

### Segmenting drivers in a model using Expand by dimension

Use **Expand by dimension** when you need one driver per dimension value from a model. This pattern is most common in legacy headcount models.

<Warning>
  When you use **Expand by dimension** directly in a model, new dimension values do not automatically create new drivers. Run the expand flow again when new values are added.
</Warning>

<Steps>
  <Step title="Select the driver">
    In a model, select the driver you want to expand.
  </Step>

  <Step title="Choose Expand by dimension">
    Open the driver menu, hover over **Dimensions**, then select **Expand by dimension**.
  </Step>

  <Step title="Choose the dimension">
    Select the dimension to use as the segment. Runway creates one driver segmented by each value in that dimension.

    <Frame>
      <img alt="Expand by dimension creating segmented drivers" />
    </Frame>
  </Step>

  <Step title="Set a formula first when possible">
    Expand by dimension works best when the source driver already has a formula filtered by the dimension you plan to use.

    <Frame>
      <img alt="Formula using a dimension filter before Expand by dimension" />
    </Frame>
  </Step>

  <Step title="Review smart-matched formulas">
    When the formula uses the same dimension as a filter, Runway smart-matches the formula to each dimension value.

    <video />
  </Step>
</Steps>

## What's next

* [Dimensions basics](/concepts/dimensions/dimensions-basics)
* [Databases basics](/concepts/databases/databases-basics)
* [Headcount planning](/guides/modeling/headcount-planning)


# Drill-ins
Source: https://runway-docs.cfo.ai/concepts/drivers/drill-ins

Use drill-ins to expand a driver row and inspect the inputs that contribute to its values.

Drill-ins let you inspect what contributes to a driver without leaving the table. Use them when you want to trace a formula, understand a variance, or show the rows and drivers behind a modeled number.

## How to use drill-ins

<Steps>
  <Step title="Choose a driver">
    In a driver table, hover over a driver row that can be expanded. A caret appears next to eligible rows.
  </Step>

  <Step title="Open inputs">
    Click the caret next to the driver name, or right-click the driver and select **Show inputs**. You can also press `⌘⏎` (`Ctrl+Enter` on Windows) on the selected row.
  </Step>

  <Step title="Review the inputs">
    The driver's inputs appear as nested child rows. Drilling into dimensional or database-backed drivers expands segment and object sub-rows, and you can keep drilling into eligible child rows.
  </Step>

  <Step title="Close inputs">
    Click the caret again, right-click the driver and select **Hide inputs**, or press `⌘⏎` (`Ctrl+Enter` on Windows) again.
  </Step>
</Steps>

<Tip>
  Drill-ins support multiple levels of depth. Expand an input line further to inspect its dependencies.
</Tip>

<Frame>
  <img alt="Driver table row expanded to show drill-in inputs" />
</Frame>

## Drill-in access

Drill-ins respect the block-level **Can drill in** access rule. For current access rules, see [Permissions](/guides/sharing/permissions) and [Roles and access](/reference/roles-and-access).

## Open detail view

Use **Open detail view** or press `⌘⇧⏎` (`Ctrl+Shift+Enter` on Windows) to open the details pane for the selected row. The details pane shows **Overview**, **Used By**, and **Plans** tabs when available. See [Driver details pane](/concepts/drivers/driver-details-pane) for more detail.

## Important notes

### Drill-ins are saved per user

Expanding drill-ins affects your own view. Other users do not see the expanded state unless they expand the row themselves.

### Want others to see a breakdown?

If you want other users to view the same rows, add selected drill-in drivers to the block from the row context menu. This makes those driver lines visible in the block instead of depending on each user's expanded drill-in state.

### Drill-in lines have a striped background

Stripes indicate drill-in lines are dynamically generated and will not appear for other users unless expanded.

<Warning>
  Drag-and-drop reordering and undo/redo are not supported for drill-in lines.
</Warning>

## What's next

* [Driver details pane](/concepts/drivers/driver-details-pane)
* [Drivers table block](/concepts/pages/drivers-table-block)
* [Permissions](/guides/sharing/permissions)


# Details pane
Source: https://runway-docs.cfo.ai/concepts/drivers/driver-details-pane

The driver details pane gives a comprehensive overview and editing options for your drivers. 

## How to access the details pane

* Click the **↗️ arrow** on any driver row.
* Use the shortcut `Cmd (Ctrl)` + `Shift` + `Enter` while a driver is selected.

<img alt="Button" />

This pane is a really handy surface to dive deep into a driver and how it fits into your model. It is especially useful for:

* Viewing and editing all driver settings in one place.
* Exploring the inputs that contribute to a driver’s values to troubleshoot discrepancies or errors.

## What's inside the driver details pane?

<img alt="Driver details pane sections" />

1. **Name** – The driver’s name.
2. **Description** – Context or notes about the driver.
3. **Models** – Lists all pages where the driver is used.
4. **Dimensions** – Explains how the driver is segmented. [Learn more about dimensions](/concepts/dimensions/dimensions-basics).
5. [**Format**](/concepts/drivers/driver-formatting) – Adjusts display settings for numeric drivers.
6. **Goal** – Assign a target value to the driver.
   * The target appears as a goal line when plotted on a chart.
   * Used in scenario comparisons or BvA (Budget vs. Actuals) to determine whether values are displayed as red or green.
   * By default, higher values are considered *better*.
7. **Rollup by** – Specifies how the driver's values aggregate when viewing time periods longer than one month, such as quarterly, year-to-date, or annual (e.g. sum, first, last).
8. [**Actuals formula**](/concepts/drivers/drivers-basics#driver-formulas) – Expanded space for editing the driver’s actuals formula.
9. [**Forecast formula**](/concepts/drivers/drivers-basics#driver-formulas) – Expanded space for editing the driver’s forecast formula.
10. [**Driver type**](/concepts/drivers/drivers-basics#driver-types) – Clearly indicates whether the driver stores **Numbers**, **Dates**, or **Attributes**.
11. **Driver timeseries** – A dedicated table displaying the driver’s values over time. The columns are controlled by settings under **Customize**.
12. [**Drill-in**](/concepts/drivers/drill-ins) – Click the caret to show all inputs contributing to this driver (i.e., referenced in its formula).
13. **Used by** – Lists all other drivers that reference this driver in their formulas.
14. [**Plans**](/concepts/plans) – Displays any Plans applied to this driver.
15. **Breadcrumbs** – Shows where the driver is located in your model.
16. **Delete** – Click the **trash can** icon to delete the driver.
17. **Customize menu** – Adjusts which columns and time ranges are displayed in the driver timeseries table.


# Formatting drivers
Source: https://runway-docs.cfo.ai/concepts/drivers/driver-formatting

Drivers in Runway can be formatted to display values exactly as you expect. This guide provides an overview of the different types of formatting and available options.

There are **three types of formatting** that can be applied to drivers:

1. **Global formatting** → Applies to **all drivers** across Runway.
2. **Data formatting** → Controls how **a specific driver's values** are displayed (e.g., number format, date format, precision, currency).
3. **Display formatting** → Controls how **a specific driver appears** in **driver table blocks** (e.g., color, text style, name format).

## Global formatting

Global formatting settings apply to **all drivers** in Runway across **every page**. These settings can be found in **Settings → General** and control the following defaults:

* **Currency format** → Set to **USD** by default, but can be changed globally if desired.
* **Negative number display** → Defaults to using a **negative sign** (e.g., `-1000`), but can be switched to **parentheses** (e.g., `(1000)`).
* **Number precision** → Defaults to using **up to two decimal places** for values that include decimals.

These settings ensure consistency across all drivers while allowing customization as needed.

<img alt="Formatting General" />

## Data formatting

Data formatting determines how a **specific driver's values** (numbers or dates) appear across all tables, including both **driver tables** and **database tables**.

To adjust data formatting, **right-click** on a numeric driver in a table and use the options shown.

* **Format** — Drivers can be formatted as:
  * **Automatic** → Attempts to infer the best display format based on the driver’s formula. (e.g., If an input is a percentage, the result will also be formatted as a percentage.)
  * **Currency** → Displays values in the selected currency.
  * **Number** → Shows numbers with decimal precision.
  * **Integer** → Displays whole numbers only (no decimals).
  * **Percentage** → Formats the value as a percentage.
* **Currency** — Currency options only appear once you first set the driver format to **Currency**. Until then, the currency dropdown will be hidden. When a driver has been set to the currency format, an additional setting will appear per the screenshot below. Options for currencies at present include:
  * **US Dollars (USD)**
  * **Australian Dollars (AUD)**
  * **Canadian Dollars (CAD)**
  * **Euros (EUR)**
  * **British Pounds (GBP)**
  * **Indian Rupees (INR)**
  * **Japanese Yen (JPY)**
  * **New Zealand Dollars (NZD)**
* **Precision** → can set numeric drivers to display between **0 and 5 decimal places** for better control over rounding and accuracy.

  <img alt="Formatting Data" />

## Display formatting

The display formatting of a driver applies **globally** across all **driver table blocks**, ensuring consistency wherever the driver appears. However, these settings **do not affect databases**.

The following options control how drivers are visually presented:

* **Background color** — Changes the driver row’s background color. Options include:
  * Default (white)
  * Grey
  * Green
  * Yellow
  * Red
* **Text style** — Adjusts how the driver name and values are displayed:
  * Bold
  * Strikethrough
  * Underline
  * Multiple styles can be applied at once.
* **Indent / Outdent** — Adjusts the indentation of the driver for better organization and readability.
* **Hide driver name, Hide segment, and Segment style** — These options apply to **drivers with dimensions**. You can read more [about dimensions here](/concepts/dimensions/dimensions-basics).
* **Cell-specific styling** — You can also apply **background and text formatting** to **specific month values** within a table. To do this, **right-click a month’s value** and apply the desired style.

  <img alt="Formatting Display" />

Here’s an overview of the available formatting options, categorized as above, as they appear in a driver table:

<img alt="Images" />

<img alt="Images" />


# Drivers basics
Source: https://runway-docs.cfo.ai/concepts/drivers/drivers-basics

Drivers are the core building blocks of your model in Runway. They represent time series data, allowing you to define, interpret, and connect different parts of your model to track business performance over time.

Drivers are the numbers, dates, and dimension values that power your model over time. Use drivers when you need a business metric or assumption that can be referenced in formulas, shown in tables, visualized in charts, or segmented by dimensions.

<Info>
  This article focuses on drivers in driver tables. Drivers can also be used in databases, which have additional behavior covered in [Formulas in databases](/concepts/databases/formulas-in-databases).
</Info>

## What is a driver?

A **driver** in Runway is a structured chunk of **time series data**. It has a human-readable name and represents values that shape your business model, such as revenue, expenses, headcount, renewal dates, or department attributes.

Drivers act as the primary elements in tables and formulas. Conceptually, a driver is similar to:

* A row in an Excel model
* A variable in other modeling systems

## Why use drivers?

Drivers offer several advantages over traditional spreadsheet modeling:

* **Portable:** Drivers can be referenced in formulas, added to tables, and visualized in charts without dealing with cell ranges. They stay synced across your model.
* **Time-native:** Every business assumption changes over time. Drivers make it easy to project those changes across months.
* **Dimensional:** Drivers can use [dimensions](/concepts/dimensions/dimensions-basics) to structure your model as complexity grows.

<Frame>
  <img alt="Driver table showing several drivers as monthly time series" />
</Frame>

## Driver formulas

Drivers contain formulas that define their values across different time periods.

* **Forecast formula:** Calculates projected values for future periods after the last close.
* **Actuals formula:** Defines historical values through the last close.

<Frame>
  <img alt="Driver table showing forecast and actuals formula columns" />
</Frame>

### Formula inheritance

Runway applies smart defaults to fill in missing formulas when needed. The inheritance hierarchy determines how formulas are applied.

**Actuals formula inheritance hierarchy:**

| Priority | Rule                                                                       |
| -------- | -------------------------------------------------------------------------- |
| First    | Explicitly set actuals formula for the driver.                             |
| Next     | Default actuals formula set for the database column the driver belongs to. |
| Fallback | Driver's forecast formula, if no actuals formula is set.                   |

**Forecast formula inheritance hierarchy:**

| Priority | Rule                                                                                                                                           |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| First    | Explicitly set forecast formula for the driver.                                                                                                |
| Next     | Default forecast formula set for the database column the driver belongs to.                                                                    |
| Fallback | Global default formula: the driver's own value from last month (shown in the editor as the driver's name with the **Last month** time period). |

Learn more about [formulas in databases](/concepts/databases/formulas-in-databases).

<Frame>
  <img alt="Formula editor showing an inherited default formula" />
</Frame>

### Overriding formula values

Hardcoding a cell value overrides the formula for that period. Overridden cells are visually marked so you can distinguish them from formula-driven values. You can also tag overrides to a plan to keep the business context attached to the change. Learn more in [Plans](/concepts/plans).

### Drill-ins

When you need to understand why a driver has a value, use [drill-ins](/concepts/drivers/drill-ins) to expand the driver row and inspect the inputs that feed its formula.

## Driver types

Drivers store time series data in one of three user-facing formats:

* **Number:** Quantitative values like revenue, expenses, or headcount.
* **Date:** Time-based values like project start dates or contract renewals.
* **Dimension:** Categorical values from dimensions, often used when working with HRIS data or other segmented sources.

<Note>
  When entering explicit dates in formulas, use the format `YYYY-MM-DD` enclosed in single quotes.
</Note>

<Frame>
  <img alt="Driver type menu showing number, date, and dimension options" />
</Frame>

In driver tables, new drivers default to the **Number** type. You can change the type later from **Format and display**.

The type can be updated later, but with constraints:

* Driver formulas must output values that match the driver's type.
* Date functions that return dates require Date drivers.

<Warning>
  If a driver formula outputs an incompatible type, the cell displays a `TYPE` error. The tooltip explains that the driver or one of its formula inputs is performing an operation across incompatible types or resolves to a non numeric value.
</Warning>

Date drivers are most useful when working with [drivers in databases](/concepts/databases/formulas-in-databases).

## What's next

* [Formulas basics](/concepts/formulas/formulas-basics)
* [Drill-ins](/concepts/drivers/drill-ins)
* [Segmenting drivers](/concepts/dimensions/segmenting-drivers)


# Duplicating, removing & deleting
Source: https://runway-docs.cfo.ai/concepts/drivers/duplicate-remove-delete

Duplicate drivers for experimentation, remove them from a block, or delete them from the model when you no longer need them.

Duplicating, removing, and deleting drivers are different actions. Use duplicate when you want a new independent driver, remove when you only want to clean up the current table, and delete when the driver should leave the model.

## Duplicating drivers

Duplicating a driver creates a new independent driver with the same formulas, segments, and values as the original. The copy has "Copy" appended to the name, and it has no dependency link back to the original.

Any segments from the original driver are copied to the new driver. See [Keyboard shortcuts](/get-started/keyboard-shortcuts) for the duplicate shortcut.

<Warning>
  If you often duplicate drivers and swap out logic, consider dimensional modeling in databases instead. It is usually more scalable.
</Warning>

If you want a new driver connected to an existing set of segments, create a driver with the same name, then use the driver context menu to make it a subdriver of the existing segmented set.

<video />

## Removing vs. deleting drivers

* **Remove from block:** Removes the driver only from the current view. The driver still exists in Runway, remains available in other blocks, and existing formula references continue to work.
* **Delete:** Removes the driver from the model and all tables where it appears. Formulas that reference the deleted driver can break.

<Frame>
  <img alt="Driver context menu with remove and delete actions" />
</Frame>

Removing a driver from every table does not delete it. These drivers appear in **Unlisted Drivers**.

<Frame>
  <img alt="Unlisted Drivers page showing drivers not present on a page or model" />
</Frame>

## What's next

* [Drivers basics](/concepts/drivers/drivers-basics)
* [Segmenting drivers](/concepts/dimensions/segmenting-drivers)
* [Keyboard shortcuts](/get-started/keyboard-shortcuts)


# Formulas basics
Source: https://runway-docs.cfo.ai/concepts/formulas/formulas-basics

Formulas define the logic behind drivers in Runway, from connected actuals to forecast assumptions.

Formulas are how drivers calculate values over time. Use them when you want a value to come from source data, other drivers, database rows, time-based logic, or a repeatable assumption instead of a manual entry.

## Where to write formulas in Runway

There are four primary places where you interact with formulas in Runway. Each has its own context depending on whether you are working with standalone drivers, databases, or HRIS data.

### Driver table blocks

When working in a [driver table block on a page](/concepts/pages/drivers-table-block) or in a [model](/concepts/models/models-basics), you often write or update formulas for the drivers you see there.

A driver table block can contain drivers created directly in the block, pulled from other driver table blocks, or drivers originating from databases. Because drivers are portable, editing a formula in one place changes it everywhere that driver is used.

You can access a driver's formulas from the formula columns, the formula button next to the driver name, or the driver's details pane. See [Keyboard shortcuts](/get-started/keyboard-shortcuts) for formula-column shortcuts.

<Frame>
  <img alt="Formula button next to a driver name in a driver table" />
</Frame>

The [driver details pane](/concepts/drivers/driver-details-pane) gives you more room to work and more context on the driver.

### Driver default column formulas in a database

Most databases in Runway contain one or more driver columns. These columns can be:

* Auto-generated through [database configuration](/concepts/databases/databases-basics#configuring-a-database)
* Manually added to extend the database with calculated drivers

No matter how a driver column is created, it supports [default actuals and forecast formulas](/concepts/databases/formulas-in-databases#default-formulas). These are set at the column level and apply to all rows unless a specific row has an override.

You can view or edit the default formula when displaying a driver column as a time series or as a single value.

<Frame>
  <img alt="Database driver column shown as a time series with a formula button" />
</Frame>

<Frame>
  <img alt="Database driver column shown as a single value with a formula button" />
</Frame>

### Row-level driver formulas in a database

Rows in a driver column inherit the default column-level formulas by default. You can override the formula for a specific row when one segment needs custom logic.

You can do this by editing the row's formula cell when a driver column is shown as a time series, or by using the full time series view of a database to scan and edit multiple overrides in one place.

<Frame>
  <img alt="Database row-level formula override in time series view" />
</Frame>

Formula overrides at the row level take precedence over the column default for that row only. Clear the override to revert to the inherited column formula.

### Field column formulas in an HRIS database

HRIS databases behave differently from standard Runway databases. You can define formulas at the column level, but row-level formula overrides are not currently supported.

That means the logic you define for a field column applies uniformly across all employees in the database. Learn more in [HRIS databases](/concepts/databases/hris-databases).

## Forecast vs. actuals formulas

Every driver in Runway supports two formulas:

* **Actuals formula:** Used for all months up to and including your [last close date](/concepts/last-close).
* **Forecast formula:** Used for all months after last close.

This split separates how historical values are calculated from how future assumptions are modeled. If an actuals formula is not explicitly set, Runway falls back to the forecast formula according to [formula inheritance logic](/concepts/drivers/drivers-basics#formula-inheritance).

## What's next

* [Formulas syntax](/concepts/formulas/formulas-syntax)
* [Functions & operators](/concepts/formulas/functions-operators)
* [Troubleshooting errors](/reference/errors-troubleshooting)


# Formulas syntax
Source: https://runway-docs.cfo.ai/concepts/formulas/formulas-syntax

Learn how to reference drivers, dimensions, database columns, and date ranges in Runway formulas.

Formulas in Runway are made up of three key components:

1. **Operators** — symbols like `+`, `-`, `>`, and others used for basic logic or math.
2. **Functions** — built-in helpers like `ifError`, `avg`, `count`, etc.
3. **Data references** — the core of your model: this includes drivers created in a driver table block, segmented drivers from a database, specific segments of a driver, or entire database columns.
   <img alt="Formula Syntax" />

This article will explain how to reference data within your formulas. To learn more about available operators and functions, [see this guide](/concepts/formulas/functions-operators).

## Referencing data in formulas

In Runway, you can reference various types of data in formulas — from individual drivers to entire driver groups, segmented drivers, or even full databases. Here’s how to work with each type:

### Driver groups (from models)

[Driver groups created in models](/concepts/models/grouping-drivers) can be referenced as a single unit.

* Type the name of the group into the formula editor to reference the entire group.
  <img alt="Driver Group 1" />
* Runway will automatically wrap the reference in a `sum()` function since groups typically contain multiple drivers.
  <img alt="Driver Group 2" />
* You can change this aggregation to something else, like `avg()` or `max()`, depending on your use case.

### Unsegmented drivers

These are standard drivers created in a [model](/concepts/models/models-basics) or on a [page](/concepts/pages/drivers-table-block), without any associated dimensions.

* You can reference them by simply typing the name of the driver into the formula editor.
  <img alt="Unsegmented Driver 1" />
* They appear in the formula as-is, without any wrapping function.
  <img alt="Unsegmented Driver 2" />

### Segmented drivers

Drivers can be segmented by one or more dimensions (like product, department, or region).

* You can reference them by searching for the column name alone.

  <img alt="Segmented Drivers 1" />
* Or together with the dimension name to narrow it down.

  <img alt="Segmented Drivers 2" />
* When added to a formula, these drivers are automatically wrapped in a `sum()` function, because they include many segments.

  <img alt="Segmented Drivers 3" />
* As with groups, you can modify the function used to match your intent — for example, switching from `sum()` to `count()` or `avg()`.

### Specific segment of a driver

A driver can contain many segments. If you want to reference a single segment rather than the entire segmented driver:

* Use the search bar in the formula editor to search by the driver name plus the dimension attributes you’re targeting.

  <img alt="Sub Driver 1" />
* When inserted into the formula, the reference will display the driver name and attributes as-is, without any wrapping function, since it points to a single segment.

  <img alt="Sub Driver 2" />

### Multiple segments of driver

If you want to include more than one segment from a driver:

* Start by selecting a [segmented driver](/concepts/dimensions/segmenting-drivers) or a [specific segment](/concepts/dimensions/segmenting-drivers) in the formula editor, as described in the earlier sections.
* Then, expand the filters to include all relevant segments you want to reference.

As you update the filters:

* If your selection **matches a single existing segment**, the formula will resolve to that **specific segment**.

  <img alt="Multi Segment 1" />
* If your selection **spans multiple segments**, the formula will reference the **segmented driver as a whole**, with filters applied.

  <img alt="Multi Segment 2" />

<Warning>
  If your formula is referencing multiple segments, be sure to wrap the reference in an aggregator like `SUM()`. Otherwise, you'll likely run into a `TYPE` error.
</Warning>

### Database column

* To reference a column from a database, start by searching for the **database name** or the **column name** in the formula editor.

  <Info>
    Note that a driver column in a database can be referenced either via **database\_name.column\_name** or as **segmented\_driver\_name** The main advantage of the former is that you can filter based on any of the columns in the database; the main advantage of the latter is a more concise pill in the formula.
  </Info>
* In the search results, columns will appear in the format: **database\_name.column\_name** so you can easily identify the correct reference.

  <img alt="Database Column 1" />
* When added to a formula, the reference displays:

  * A **database icon** for easy identification,
  * The **database name**, and
  * The **column name**.

  <img alt="Database Column 2" />
* Runway automatically wraps the reference in a `sum()` function, since database columns contain many rows. You can change this to another aggregation function if needed.
* Click the database name in the formula pill to:

  * Switch to a different column, or
  * Apply filters to narrow down the set of rows included in the result.

  <img alt="Database Column 3" />
* Filters can be applied using any column in the database—not just the one you're referencing in the formula.

  <img alt="Database Column 4" />

### *This Segment* - dynamic matching

In previous sections, we walked through how to filter a segmented driver or database reference to only include specific segments. While useful, that approach can become tedious and error-prone when modeling at scale—especially if you’re trying to apply similar logic across many segments.

That’s where **This Segment** comes in. It allows you to dynamically match data based on the dimension values of the driver currently being evaluated—eliminating the need to hardcode filters for every segment. This is especially powerful when:

* Setting default formulas in databases
* Writing self-referential logic across rows
* Referencing other drivers or columns that have segmentation overlap

How it works:

* You can search for **This Segment** in the formula editor.

  <img alt="This Segment 1" />
* You can apply **partial matching** — filtering just on one or more specific dimensions—or **full matching** to filter across all dimensions.

  <img alt="This Segment 2" />

When referencing database columns, you can use *This Segment* in a few more ways:

* **Numeric filters**: Dynamically match rows where a column (like usage tier) equals the value of a numeric driver (like transaction volume).

  <img alt="This Segment 3" />
* **Date filters**: Match rows using a date column (like contract start) against a date driver for that segment.

  <img alt="This Segment 4" />

<Info>
  For a deeper dive on using *This Segment* in databases, see [Formulas in databases](/concepts/databases/formulas-in-databases#dynamic-formulas-using-this-segment).
</Info>

### Numbers, strings, and dates

In addition to referencing data from across Runway, you can also enter raw values directly into formulas:

* **Numbers:** Just type the number directly (e.g., `1000`).

  <img alt="Numbers" />
* **Strings:** Use either single quotes or double quotes (e.g., `'hello'` or `"hello"`). Both work the same way.
* **Dates:** Use the format `'YYYY-MM-DD'` — you can use either single or double quotes (e.g., `'2025-06-01'` or `"2025-06-01"`). You can also write a date in the format `'YYYY'` and Runway will auto-populate as the first day of the year (e.g., if you type `'2025'`, Runway will populate `'2025-01-01'`).

  <img alt="Dates" />

### Dimension value

When setting default formulas at a column level i.e. in databases, you may want to set conditional logic based on the values of a dimension. You can set this up using if() statements and placing dimension values in your formulas.

<img alt="Dimension Value" />

## Using date ranges in formulas

Whenever you reference another value (driver, database columns, etc.) in a formula, you’ll always see this filter: `Date = <date range>`

<img alt="Date Range 1" />

This filter controls which month’s data is pulled from that reference when the formula runs. Since Runway stores values over time and evaluates formulas month‑by‑month, you must tell it *which* month (or months) to use when referencing other data.

* **Default behavior**
  * **This month** is applied to ordinary references.
  * **Last month** is used when a driver's formula references itself, to prevent circular logic.
* **Available options** for single-month ranges:

  * **This month** — Use the corresponding month's value.
  * **Last month** — Shift back by one month.
  * **Last close** — Use the last closed month.
  * **Most recent value** — Pull the latest non-null entry. Ideal for [propagating sparse data](/guides/modeling/propagating-sparse-data) over time.
  * **Next available value**
  * **Most recent or first value**
  * **One year ago**
  * **Specific date**
  * `<Driver value> months ago` — Dynamically looks back *N* months, where *N* is the value of another driver.
  * `<Date driver value>.Month` — Use the month from a Date driver.
  * **Custom…** — Enter a custom relative offset, such as `3 months ago` or `2 months from now`.

  Custom ranges can also use **Last close** as the anchor. A custom month offset renders as **Last close**, `N month(s) before Last close`, or `N month(s) after Last close` depending on the offset.

  If you keep scrolling in this menu, you'll also see multi-month date ranges, including **Quarter-to-date**, **Year-to-date**, **Last 3 months of actuals**, **Last 6 months of actuals**, **Last 12 months of actuals**, **Specific date range**, and **Custom range…**.

  <img alt="Date Range 2" />
* **How it works**

  For each month’s calculation, Runway pulls the referenced value from every month in the chosen range (e.g. for “Last 3 months” in April, it fetches values from Jan, Feb, Mar).

  <Info>
    Given that multiple values are being fetched for each month, references to multi-month date ranges must be wrapped in an aggregation function like `sum()`, `avg()`, or `max()`.
  </Info>
* **Why it’s useful**
  * **Rolling averages & trends** Smooth out seasonality or one‑off spikes.
  * **Cumulative metrics** Track YTD totals, quarterly results, or any custom range.
  * **Forecast inputs** Base projections on recent history rather than just the prior month.


# Functions and operators
Source: https://runway-docs.cfo.ai/concepts/formulas/functions-operators

Reference the functions, operators, and special values available in Runway formulas.

Use functions and operators when a formula needs math, aggregation, date logic, comparisons, or conditional behavior. For formula reference syntax, start with [formula basics](/concepts/formulas/formulas-basics) and [formula syntax](/concepts/formulas/formulas-syntax).

## Operators

| Operator    | Usage                         | Description                                                            | Things to keep in mind                                                                                           |
| ----------- | ----------------------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `+`         | `value1 + value2`             | Adds two values.                                                       |                                                                                                                  |
| `-`         | `value1 - value2`             | Subtracts the second value from the first.                             |                                                                                                                  |
| `*`         | `value1 * value2`             | Multiplies two values.                                                 |                                                                                                                  |
| `/`         | `value1 / value2`             | Divides the first value by the second.                                 |                                                                                                                  |
| `%`         | `value1 % value2`             | Returns the remainder when `value1` is divided by `value2`.            |                                                                                                                  |
| `^`         | `base ^ exponent`             | Raises `base` to `exponent`.                                           |                                                                                                                  |
| `==`        | `value1 == value2`            | Checks whether two values are equal.                                   | Date comparisons work. For example, `if(thisMonth() == '2025-01-01', 1, 0)` returns 1 in January 2025.           |
| `!=`        | `value1 != value2`            | Checks whether two values are not equal.                               | Date comparisons work. For example, `if(thisMonth() != '2025-01-01', 1, 0)` returns 1 outside January 2025.      |
| `>`         | `value1 > value2`             | Checks whether the first value is greater than the second.             | Date comparisons work. For example, `if(thisMonth() > '2025-01-01', 1, 0)` returns 1 after January 2025.         |
| `<`         | `value1 < value2`             | Checks whether the first value is less than the second.                | Date comparisons work. For example, `if(thisMonth() < '2025-01-01', 1, 0)` returns 1 before January 2025.        |
| `>=`        | `value1 >= value2`            | Checks whether the first value is greater than or equal to the second. | Date comparisons work. For example, `if(thisMonth() >= '2025-01-01', 1, 0)` returns 1 in or after January 2025.  |
| `<=`        | `value1 <= value2`            | Checks whether the first value is less than or equal to the second.    | Date comparisons work. For example, `if(thisMonth() <= '2025-01-01', 1, 0)` returns 1 in or before January 2025. |
| `(` and `)` | `(condition1 AND condition2)` | Groups calculations or logical expressions.                            |                                                                                                                  |

## Aggregation

| Function       | Signature                            | Description                                                                                                                      | Example                                       | Things to keep in mind                                                                       |
| -------------- | ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- | -------------------------------------------------------------------------------------------- |
| `sum()`        | `sum(reference)`                     | Returns the sum of a database field or dimensional driver reference.                                                             | `sum(Employees.Salary)`                       |                                                                                              |
| `sumProduct()` | `sumProduct(reference1, reference2)` | Calculates the sum of the products of corresponding entries in two database field or dimensional driver reference.               | `sumProduct(Deals.Quantity, Deals.UnitPrice)` | Both references must have the same number of entries and corresponding dimensional segments. |
| `count()`      | `count(reference)`                   | Returns the number of values in a database field or dimensional driver reference.                                                | `count(Employees.Name)`                       |                                                                                              |
| `avg()`        | `avg(reference)`                     | Returns the numerical average value in a database field or dimensional driver reference.                                         | `avg(Employees.Salary)`                       |                                                                                              |
| `min()`        | `min(reference...)`                  | Returns the numerical minimum value in a list of values.                                                                         | `min(Deals.ContractValue)`                    |                                                                                              |
| `max()`        | `max(reference...)`                  | Returns the numerical maximum value in a list of values.                                                                         | `max(Deals.ContractValue)`                    |                                                                                              |
| `first()`      | `first(reference...)`                | Returns the first value in a list of values.                                                                                     | `first(HeadcountByDepartment)`                |                                                                                              |
| `firstValue()` | `firstValue(reference...)`           | Returns the first non-null value in a list of values.                                                                            | `firstValue(RevenueByRegion)`                 |                                                                                              |
| `last()`       | `last(reference...)`                 | Returns the last value in a list of values.                                                                                      | `last(RevenueByRegion)`                       |                                                                                              |
| `lastValue()`  | `lastValue(reference...)`            | Returns the last non-null value in a list of values.                                                                             | `lastValue(RevenueByRegion)`                  |                                                                                              |
| `single()`     | `single(reference...)`               | Checks to see if its list of references returns a single value. Returns the value if true, otherwise returns an ASSERTION error. | `single(Employees.Department)`                |                                                                                              |

## Math & rounding

| Function      | Signature                    | Description                                                                                                                                                    | Example | Things to keep in mind                                                                             |
| ------------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- | -------------------------------------------------------------------------------------------------- |
| `round()`     | `round(value, [places])`     | Rounds a number to a certain number of decimal places according to standard rules. Maximum precision is 5 decimal places.                                      |         | Coarser rounding than the ones place is not supported; do not use negative values for `[places]`.  |
| `roundDown()` | `roundDown(value, [places])` | Rounds down a number to a specified number of decimal places. If places is omitted, rounds down to the nearest integer. Maximum precision is 5 decimal places. |         |                                                                                                    |
| `roundUp()`   | `roundUp(value, [places])`   | Rounds up a number to a specified number of decimal places. If places is omitted, rounds up to the nearest integer. Maximum precision is 5 decimal places.     |         | `-roundDown(-value)` produces the same round-up behavior and can help when reading older formulas. |
| `floor()`     | `floor(value, [factor])`     | Rounds down a number to the nearest multiple of a factor. If factor is omitted, rounds down to the nearest integer.                                            |         |                                                                                                    |
| `ceiling()`   | `ceiling(value, [factor])`   | Rounds up a number to the nearest multiple of a factor. If factor is omitted, rounds up to the nearest integer.                                                |         |                                                                                                    |
| `power()`     | `power(base, exponent)`      | Returns the value of base raised to the power of exponent. Aliases: pow(base, exponent); base^exponent.                                                        |         |                                                                                                    |
| `exp()`       | `exp(value)`                 | Returns the value of e raised to the power of value.                                                                                                           |         |                                                                                                    |
| `log()`       | `log(argument, [base])`      | Returns the logarithm of argument with a given base. If base is not provided, it defaults to 10.                                                               |         |                                                                                                    |
| `ln()`        | `ln(argument)`               | Returns the natural logarithm of argument.                                                                                                                     |         |                                                                                                    |

## Date calculation

| Function        | Signature                                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Example | Things to keep in mind                                                           |
| --------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- | -------------------------------------------------------------------------------- |
| `dateDiff()`    | `dateDiff(start_date, end_date, unit)`                      | Returns the number of whole "units" between the start\_date and end\_date. Valid units are "d", "m", "w", "q", "y" (days, months, weeks, quarters, years).                                                                                                                                                                                                                                                                                                                                                           |         | If the result is negative, consider flipping `start_date` and `end_date`.        |
| `dateAdd()`     | `dateAdd(date, quantity, unit)`                             | Returns the sum of the date plus the quantity in units. Valid units are "d", "m", "w", "q", "y" (days, months, weeks, quarters, years).                                                                                                                                                                                                                                                                                                                                                                              |         | This returns a date. Use a Date driver when the formula result should be a date. |
| `dateSub()`     | `dateSub(date, quantity, unit)`                             | Returns the sum of the date minus the quantity in units. Valid units are "d", "m", "w", "q", "y" (days, months, weeks, quarters, years).                                                                                                                                                                                                                                                                                                                                                                             |         | This returns a date. Use a Date driver when the formula result should be a date. |
| `netWorkDays()` | `netWorkDays(start_date, end_date, [weekends], [holidays])` | Returns the number of net work days between start\_date (inclusive) and end\_date (exclusive) excluding holidays and weekends. The optional weekend parameter expects a string of 7 characters, each representing a day of the week. 1 means the day is a weekend, 0 means it is a work day. The first character represents Monday (default is '0000011'). The holiday optional parameter allows you to specify a list of holidays as a string of comma separated dates in the format YYYY-MM-DD (default is empty). |         |                                                                                  |

## Date access

| Function         | Signature                       | Description                                                                                                              | Example | Things to keep in mind |
| ---------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | ------- | ---------------------- |
| `startOfMonth()` | `startOfMonth(date_expression)` | Returns the first day of the month for the date expression.                                                              |         |                        |
| `endOfMonth()`   | `endOfMonth(date_expression)`   | Returns the last day of the month for the date expression.                                                               |         |                        |
| `thisMonth()`    | `thisMonth()`                   | Returns the first day of the month being evaluated.                                                                      |         |                        |
| `lastMonth()`    | `lastMonth()`                   | Returns the first day of the previous month being evaluated.                                                             |         |                        |
| `thisQuarter()`  | `thisQuarter()`                 | Returns the first day of the quarter being evaluated.                                                                    |         |                        |
| `lastQuarter()`  | `lastQuarter()`                 | Returns the first day of the previous quarter being evaluated.                                                           |         |                        |
| `thisYear()`     | `thisYear()`                    | Returns the first day of the year being evaluated.                                                                       |         |                        |
| `lastYear()`     | `lastYear()`                    | Returns the first day of the previous year being evaluated.                                                              |         |                        |
| `daysInMonth()`  | `daysInMonth()`                 | Returns the number of days in the month being evaluated.                                                                 |         |                        |
| `year()`         | `year(date_expression)`         | Returns the year of the date expression. Example: year('2025-01-01') returns 2025.                                       |         |                        |
| `quarter()`      | `quarter(date_expression)`      | Returns the quarter of the date expression. Example: quarter('2025-04-24') returns 2.                                    |         |                        |
| `month()`        | `month(date_expression)`        | Returns the month of the date expression. Example: month('2025-03-01') returns 3.                                        |         |                        |
| `weeknum()`      | `weeknum(date_expression)`      | Returns the number of weeks from the start of the year of the date expression. Example: weeknum('2025-03-01') returns 9. |         |                        |
| `day()`          | `day(date_expression)`          | Returns the day of the month of the date expression.                                                                     |         |                        |

## Logic & error handling

| Function     | Signature                                               | Description                                                                                                                          | Example | Things to keep in mind                                                                                  |
| ------------ | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------- |
| `if()`       | `IF(logical_expression, value_if_true, value_if_false)` | Returns one value if a logical expression is TRUE and another if it is FALSE.                                                        |         | The condition must be a logical expression, such as `1 == 1`. Values can be nested formula expressions. |
| `ifError()`  | `ifError(value, value_if_error)`                        | Returns value if it does not evaluate to an error and value\_if\_error otherwise. The following error types are handled: NULL, DIV/0 |         | This does not suppress circular-reference (`CIRC`) errors.                                              |
| `coalesce()` | `coalesce(val1, val2, ..., val_n)`                      | Returns the first non-null value.                                                                                                    |         | Filtered pills that return zero results are treated as null. This is useful for switch-style logic.     |
| `and()`      | `and(expression1, expression2, ...)`                    | Returns true if all expressions are true/non-null/non-zero, otherwise returns false.                                                 |         | Use parentheses to make nested logic easier to read.                                                    |
| `or()`       | `or(expression1, expression2, ...)`                     | Returns true if any expression is true/non-null/non-zero, otherwise returns false.                                                   |         | Use parentheses to make nested logic easier to read.                                                    |

## Time-unit conversion

No public time-unit conversion functions are exposed in the formula autocomplete registry.

## Special keywords

| Item                     | Where it appears                                     | Description                                                                                                           | Things to keep in mind                                                                                        |
| ------------------------ | ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `NULL`                   | Values section                                       | Represents the NULL value.                                                                                            |                                                                                                               |
| `this.` / This Segment   | This Segment and This Database autocomplete sections | References the current segment or database row context when matching dimensions and database fields.                  | Use this for formulas that should adapt across segments instead of hardcoding each filter.                    |
| `lastClose()`            | Function autocomplete                                | Returns the last closed month.                                                                                        | Use it when a formula should anchor to the last closed month rather than the month currently being evaluated. |
| Relative date references | Date filters on formula references                   | Includes This month, Last month, Last close, One year ago, Quarter-to-date, Year-to-date, and rolling actuals ranges. | References with multi-month ranges usually need an aggregation function such as `sum()`, `avg()`, or `max()`. |

## What's next

* [Formula basics](/concepts/formulas/formulas-basics)
* [Formula syntax](/concepts/formulas/formulas-syntax)
* [Formulas in databases](/concepts/databases/formulas-in-databases)


# Last close
Source: https://runway-docs.cfo.ai/concepts/last-close

Last close in Runway is a global, manually adjusted setting that determines the cutoff between actuals and forecasts across your entire workspace.

## What is last close?

It defines the latest month through which **actuals formulas** apply, and from which point **forecast formulas** begin to take over. In other words, it sets the boundary between historical data and your forward-looking assumptions.

<img alt="Lastclose" />

## Where to find last close?

You’ll see the **last close** marker appear at the top of a month when viewing time series data anywhere in Runway. It visually marks the boundary between actuals and forecasts:

* In a driver table block on a [model](/concepts/models/models-basics) or [page](/concepts/pages/drivers-table-block):

  <img alt="Lastclose In Model" />
* In the [detail pane](/concepts/drivers/driver-details-pane) for a driver:

  <img alt="Lastclose In Details Pane" />
* When you [expand a database column as a time series](/concepts/databases/databases-basics#show-a-column-as-timeseries):

  <img alt="Lastclose In Db" />
* When displaying the entire [database as timeseries](/concepts/databases/databases-basics#show-all-columns-as-timeseries):

  <img alt="Lastclose In Db As Timeseries" />
* On a [chart](/concepts/pages/charts-block):

  <img alt="Lastclose In Charts" />

## When to update last close?

You can update **last close** at any time using the date picker. This setting controls the cutoff between actuals and forecasts throughout your entire Runway model.

* **Actuals data is always syncing** in the background—typically every 24 hours.
* Once you change the last close date, actuals formulas will populate data up to (and including) that new date across all drivers.

Here are the most common times users update last close:

1. **After monthly close** Once your accounting books are closed, move last close forward by one month to reflect the latest actuals in your model. This is typically the [**first step in running a BvA**](/guides/modeling/bva) (Budget vs. Actuals) comparison.
2. **For intra-month analysis**

   Because Runway syncs actuals data daily, you can move Last Close forward into the current month to preview how actuals are progressing—before books are formally closed. This is especially helpful for keeping tabs on marketing spend, sales activity, or general ledger data mid-month.
3. **To load in a budget**

   If your budget was created and locked earlier than your current working month, you may need to temporarily move last close backward. For example, if you’re starting to model in Runway in March 2025 but your budget was finalized in December 2024, you’d move last close back to December to input budget values. This ensures your model includes the correct baseline for BvA tracking going forward.

## Last close and hardcodes

Hardcoded values always take precedence over formulas—whether on the actuals or forecast side of the last close boundary. Here’s how this plays out in different scenarios:

* **Hardcoded forecast value with no actuals formula**

  If you’ve entered a hardcoded value in a forecast cell after last close, and that driver doesn’t have an actuals formula, moving last close forward will bring that hardcoded value into the actuals section. It will continue to display, as there’s no formula to override it.

  <img alt="Hardcode 1" />
* **Conflicting hardcoded actuals and forecasts** If you’ve hardcoded a value **before last close**, and a different hardcoded value for the same month **after last close**, the actuals-side hardcode will take precedence when last close moves forward. For example, if March 2025 has a hardcoded actual of **10M** and a hardcoded forecast of **20M**, moving last close forward into March will display the **10M** value. Move last close back, and the **20M** forecast reappears.

  <img alt="Hardcodes2" />

## Last close and Plans

[Plans](/concepts/plans) will only appear on your Plan timeline if they represent **inputs that fall after your last close date**.


# Driver grouping
Source: https://runway-docs.cfo.ai/concepts/models/grouping-drivers

Group drivers in models to organize related rows into collapsible sections and reuse them in blocks or formulas.

Driver groups keep models readable as they grow. Use groups when related drivers should collapse together, move together, or be referenced together.

## Why use driver groups?

Grouping drivers creates collapsible sections in a model.

<Frame>
  <img alt="Model with drivers organized into collapsible groups" />
</Frame>

Groups also make drivers easier to find and reuse. When adding drivers to a block, search by group name to include all or part of a group.

<Frame>
  <img alt="Driver search showing a model group result" />
</Frame>

You can also reference a whole driver group in formulas instead of selecting each driver individually.

<Frame>
  <img alt="Formula editor referencing a driver group" />
</Frame>

## How to group drivers

<Steps>
  <Step title="Select and group">
    Select the drivers you want to group, then right-click and choose **Group**. You can also use the grouping shortcut listed in [Keyboard shortcuts](/get-started/keyboard-shortcuts).

    <Frame>
      <img alt="Selected drivers grouped from the context menu" />
    </Frame>
  </Step>

  <Step title="Name the group">
    Give the new group a descriptive name.
  </Step>

  <Step title="Or create the group first">
    Scroll to the bottom of the model, click **+ Create group**, name the group, then drag drivers into it.

    <Frame>
      <img alt="Empty driver group created before drivers are added" />
    </Frame>
  </Step>
</Steps>

Once your groups are set up, drag and drop groups to reorder them.

## What's next

* [Models basics](/concepts/models/models-basics)
* [Drivers table block](/concepts/pages/drivers-table-block)
* [Keyboard shortcuts](/get-started/keyboard-shortcuts)


# Models basics
Source: https://runway-docs.cfo.ai/concepts/models/models-basics

Models in Runway are structured tables where each row represents a driver, allowing you to aggregate data, input assumptions, and build logic across drivers. While many of their capabilities overlap with driver table blocks on pages, models offer unique features like driver grouping and expanding drivers by dimension.

## What is a model?

Before diving into models, let’s quickly revisit what [**databases**](/concepts/databases/databases-basics) are for. Databases are where you store your raw data in Runway at various levels of granularity. This could include:

* Data pulled directly from integrations.
* Mapping tables you configure.
* Highly dimensional assumptions you input manually.

Databases are powerful for **modeling and transforming data at scale**, but they’re not always ideal for **presenting** or **interacting** with that data in a visual or lightweight format.

That’s where **models** and **pages** come in:

* **Models** are structured tables where each row represents a **driver**. You can include:
  * Drivers pulled from databases or other models.
  * New computed drivers created directly within the model to aggregate data or layer in assumptions.
* [**Pages**](/concepts/pages/pages-basics) are flexible canvases where you can present your data using various block types:
  * [Driver table blocks](/concepts/pages/drivers-table-block) (which replicate much of a model’s functionality).
  * [Charts](/concepts/pages/charts-block), [database views](/concepts/pages/database-block), [plans timeline](/concepts/plans#surfacing-plans-in-pages), [text, images, and videos](/concepts/pages/text-media-block).

## So why use models instead of driver tables on a page?

It's true: driver table blocks on pages cover most of what models can do. However, models currently support two key features that driver table blocks do not:

1. [**Grouping drivers**](/concepts/models/grouping-drivers) for better organization.
2. [**Expanding drivers by dimensions**](/concepts/dimensions/segmenting-drivers#segmenting-drivers-in-a-model-using-expand-by-dimension)

<Check>
  We know the line between models and pages can feel blurry. We’re actively working toward merging them into a single, more unified concept in the near future.
</Check>

## Creating a model

Start by clicking the **+** button next to a section or page in the sidebar. The new model will appear nested under that section or page.

Select **Model** as the type and give it a clear name, along with an icon or emoji for easy identification.

<img alt="Model Create" />

## Adding & removing drivers

Adding, removing, and deleting drivers in a model works exactly the same way as in a driver table block on a page. [Learn more in this guide.](/concepts/pages/drivers-table-block#managing-drivers-in-the-table)

## Additional customizations

Just like in driver table blocks on a page, models allow you to:

* [**Customize which columns to show**](/concepts/pages/drivers-table-block#customizing-table-columns)
* [**Change the time period rollup**](/concepts/pages/drivers-table-block#time-period-rollups) (e.g. monthly, quarterly, annual)
* [**Compare drivers across scenarios**](/concepts/pages/drivers-table-block#comparing-drivers-across-scenarios)
* [**Compare drivers across time periods**](/concepts/pages/drivers-table-block#comparing-drivers-across-time-periods) (e.g. MoM, QoQ, YoY)


# Rename, export & delete
Source: https://runway-docs.cfo.ai/concepts/models/rename-export-delete

As you work with models in Runway, you may need to rename, export, or delete them to keep your data organized and up to date.

## Renaming a model

There are a couple of ways to rename a model:

**From the sidebar** – Click the icon next to the model name, then select **Rename.** You can modify the name and click the icon to change it.

<img alt="Model Rename 1" />

**From the model page** – Navigate to the model, then click on its name at the top to edit it. You can also click the icon to change it.

<img alt="Model Rename 2" />

## Exporting a model

To export a model, click the icon next to its name in the sidebar, then select **Export to CSV.**

<img alt="Model Export 1" />

Alternatively, navigate to the model, click the More icon in the top-right, and select Export to CSV.

<img alt="Model Export 2" />

## Deleting a model

To delete a model, click the icon next to its name in the sidebar or the **More** icon in the top-right corner of the model, then select **Delete model**.

<img alt="Model Delete" />

Deleting a model from the sidebar does **not** delete the drivers within it. Any drivers that were only present in that model will remain in your workspace and can be found in the **Unlisted Drivers** page. If those drivers are referenced in other formulas, they’ll continue to work as expected—**formulas won’t break.**

<img alt="Unlisted" />


# Charts block
Source: https://runway-docs.cfo.ai/concepts/pages/charts-block

Chart blocks visualize drivers on pages so teams can spot trends, compare scenarios, and explain model movement.

Chart blocks bring driver values onto a page as visual reporting. Use them when a table has the right data, but a chart will make the trend, comparison, or variance easier to scan.

## Creating a chart block

<Steps>
  <Step title="Open block options">
    On a page, type **/** to access block options.
  </Step>

  <Step title="Choose Driver charts">
    Select **Driver charts**.
  </Step>

  <Step title="Choose drivers">
    Choose the drivers you want to visualize. You can add or remove drivers later.
  </Step>

  <Step title="Adjust the chart">
    New driver charts default to line charts. Use **Customize chart** to change chart type, combine drivers, adjust size, and configure labels.
  </Step>
</Steps>

## Chart types

The quick picker row shows **Line**, **Column**, **Stacked column**, **Combo**, **Value**, and **More**. The full picker includes the chart types below.

### Line

Use a line chart for trends over time.

### Column

Use a column chart for period-by-period values.

### Stacked column

Use a stacked column chart to show how multiple drivers contribute to a total.

### 100% stacked column

Use a 100% stacked column chart to compare percentage mix over time.

### Area

Use an area chart for trend magnitude when the filled area helps the story.

### Stacked area

Use a stacked area chart for cumulative trends with multiple contributors.

### 100% stacked area

Use a 100% stacked area chart to show changing percentage mix over time.

### Combo

Use a combo chart when different drivers need different visual treatments in one chart.

### Value

Use a Value chart for a compact selected-period KPI.

### Pie

Use a pie chart for a simple composition at one point in time.

### Donut

Use a donut chart for a compact composition chart.

### Nightingale

Use a Nightingale chart for radial comparisons where category magnitude matters.

### Waterfall

Use a waterfall chart to explain how a starting value moves to an ending value.

<Frame>
  <img alt="Chart type picker showing available chart options" />
</Frame>

## General chart customizations

### Combine charts

By default, each driver is displayed separately. Combine multiple drivers into a single chart when a consolidated view is easier to read.

<Frame>
  <img alt="Chart customization showing combined drivers" />
</Frame>

### Chart size

You can choose from three chart block sizes: **Small**, **Medium**, and **Large**.

* **Small** works well for compact **Value** charts.
* **Large** works well for detailed charts such as combo or stacked column charts.

<Frame>
  <img alt="Chart size menu with small, medium, and large options" />
</Frame>

### Data labels

Turn on **Data labels** when labels should always be visible instead of appearing only on hover. You can adjust font size, weight, and color under **Advanced settings** > **Label settings**.

<Frame>
  <img alt="Chart with data labels enabled" />
</Frame>

### Legend

The legend is hidden by default. You can show it on the right, left, top, or bottom of the chart. The legend is interactive, so clicking a driver toggles its visibility.

<Frame>
  <img alt="Chart legend settings" />
</Frame>

### Driver-level customizations

Click **Customize chart** and scroll to the driver list to customize each driver.

* **Change driver color:** Use a default color or choose a custom color.
* **Reuse custom colors:** Your 10 most recent custom colors are available across charts.
* **Switch the driver's axis:** Move a driver from the left Y-axis to the right Y-axis.
* **Change the driver's chart type:** Changing an individual driver type turns the chart into a combo chart.
* **Add or remove drivers:** Use search to add drivers, or use a driver's menu to remove it or open it in details.

<Frame>
  <img alt="Driver-level chart configuration panel" />
</Frame>

<Note>
  Waterfall charts use different per-driver customizations because they explain movement from a beginning value to an ending value.
</Note>

### Axis settings

In **Advanced settings** > **Axis settings**, you can:

* Move the X-axis from bottom to top.
* Show or hide a solid line for each axis.
* Show or hide axis ticks.
* Add a title to each axis.

<Frame>
  <img alt="Axis settings panel for a chart block" />
</Frame>

### Date range

Every block on a page inherits the page-level date range by default. Override the date range at the chart level when a specific chart needs a different window.

<Frame>
  <img alt="Chart date range settings" />
</Frame>

### Rollups

You can add quarterly and annual rollups to time series charts.

<Steps>
  <Step title="Open Customize chart">
    Click **Customize chart** on the chart block.
  </Step>

  <Step title="Open Rollups">
    Select **Rollups**.
  </Step>

  <Step title="Choose rollups">
    Choose **Quarterly**, **Annual**, or both.
  </Step>
</Steps>

Rollup values appear alongside monthly data so you can see trends at different time granularities.

<Note>
  Rollups work on time series charts such as line, column, area, and combo charts. They are not available for non-time series chart types like Value or Waterfall.
</Note>

## Waterfall chart customizations

Waterfall charts show how a key metric moves from a starting value to an ending value by breaking out positive and negative contributions.

* By default, the waterfall chart respects the sign of each driver. To flip an expense or another driver where lower is better, enable **Lower is better**.
* To pull the leftmost column from the end of the previous period, enable **Use as beginning value** for that driver.
* Floating bars represent how other drivers affect the starting value across the selected time range.
* Waterfall charts include settings for **Totals**, **Omit zeros**, and colors for positive, negative, and total values.

<Frame>
  <img alt="Waterfall chart customization options" />
</Frame>

## Scenario comparison on charts

Line and column charts can compare the same drivers across scenarios.

<Steps>
  <Step title="Open Compare">
    Click the **Compare** button on the chart block.
  </Step>

  <Step title="Choose scenarios">
    Select the scenarios you want to compare.

    <Frame>
      <img alt="Chart comparing a driver across scenarios" />
    </Frame>
  </Step>
</Steps>

## Exporting charts

You can export a chart block in two ways:

* Use the block menu and select **Export to CSV** to export the data.
* Right-click the chart and select **Download** to download the chart image.

<Frame>
  <img alt="Chart export menu" />
</Frame>

## Charts FAQ

<Accordion title="Can I view chart data by quarters or years instead of just months?">
  Yes. Add quarterly and annual rollups to time series charts from **Customize chart** > **Rollups**.
</Accordion>

<Accordion title="Can Waterfall charts break the selected range into quarters?">
  Waterfall charts display the selected time range as a single period. To compare quarters or years, create separate waterfall charts for each period.
</Accordion>

## What's next

* [Drivers table block](/concepts/pages/drivers-table-block)
* [Scenarios](/concepts/scenarios)
* [Exporting CSV](/integrations/exporting-csv)


# Database block
Source: https://runway-docs.cfo.ai/concepts/pages/database-block

Another widely used block type in Runway is the database block. Databases are where most of your modeling and data lives in Runway. A database block lets you bring those databases—or specific filtered slices of them—into pages, so you can layer in context from across your model for clearer storytelling and easier collaboration.

In this article, we’ll explore how to leverage **database blocks** in a page—so you can bring the right slice of data into view, add context, and share it clearly with your team.

## Adding a database block to a page

1. Type **/** to open the block menu.
2. Select **Database table**.
3. Search for and select the database you want to surface.

This adds a view of the source database to your page. Keep reading to learn how to customize what’s shown.

## Customizing the block to fit the page’s purpose

In most cases, you won’t want to show the entire database on a page—just a relevant slice of it. Runway gives you several tools to tailor the view:

* **Filter** to specify which rows to show. Learn more in [Filtering, sorting & grouping](/concepts/databases/filtering-sorting-grouping#filtering).
* **Sort** to control the row order. Learn more in [Filtering, sorting & grouping](/concepts/databases/filtering-sorting-grouping#sorting).
* **Group** rows for better readability. Learn more in [Filtering, sorting & grouping](/concepts/databases/filtering-sorting-grouping#group-by).
* **Show or hide columns** to focus on what matters. Learn more in [Databases basics](/concepts/databases/databases-basics#show-and-hide-columns).

<Warning>
  Destructive actions—like fully deleting (not filtering or hiding) a row or column—will affect the **source database** and **every other block** where that database is surfaced within the same scenario.
</Warning>

## Manually adding rows to a database block

When you share a page with a **database block**, you might expect teammates to manually add new rows—whether that’s planned headcount, vendors, or other entries.

Just note: any rows added from the block are **not limited to that block**. They are saved to the **source database** and will show up in **any other database block** where filters match the new row.

You can read more in [Adding a row](/concepts/databases/databases-basics#adding-a-row).

## Revealing anonymized data

When sharing database blocks, one of the most important data permissions to understand is [data anonymization](/guides/sharing/data-anonymization). If anonymization is enabled for a dimensional driver column, visibility follows the user's role and resource access. See [Permissions](/guides/sharing/permissions) for the current access model.

In some cases, though, you may want to grant access to a **subset of anonymized data** — a common example being headcount planning, where department leads should be able to see salary data for their direct reports.

To support this, you can **customize a specific database block on a page** to reveal hidden data. When this option is enabled:

* The anonymized values are shown in that block.
* Filters and properties on the block are locked, preventing further changes that could unintentionally expose sensitive information.

<img alt="Databases Reveal Hidden Data" />


# Drivers table block
Source: https://runway-docs.cfo.ai/concepts/pages/drivers-table-block

Driver table blocks add model drivers to pages as editable tables for reporting, planning, and review.

Driver table blocks let you bring drivers from across Runway onto a page. Use them when you want a page to show driver values, formulas, rollups, scenario comparisons, or editable planning inputs in table form.

## Creating a driver table block

<Steps>
  <Step title="Open block options">
    On a page, type **/** to access block options.
  </Step>

  <Step title="Choose Driver table">
    Select **Driver table**.
  </Step>

  <Step title="Choose drivers">
    Choose the drivers you want to include. You can add or remove drivers later.
  </Step>
</Steps>

## Customizing table columns

When you first add a driver table block, it displays the driver name and data by default. You can choose which columns appear.

<Steps>
  <Step title="Open Customize">
    Click **Customize** in the top-right corner of the block.
  </Step>

  <Step title="Open Properties">
    Select **Properties**.
  </Step>

  <Step title="Choose columns">
    Show or hide columns such as **Data**, **Actuals Formula**, **Forecast Formula**, **Used By**, **Graph**, and **Rollup**.

    <Frame>
      <img alt="Driver table properties panel with column toggles" />
    </Frame>
  </Step>
</Steps>

## Viewing formulas in the table

Driver table blocks can show formula columns alongside values.

<Steps>
  <Step title="Open Customize">
    Click **Customize** in the top-right corner of the block.
  </Step>

  <Step title="Open Properties">
    Select **Properties**.
  </Step>

  <Step title="Show formula columns">
    Enable **Actuals Formula** or **Forecast Formula**.
  </Step>
</Steps>

Use the formula toolbar button labeled **Open formulas** to show formula columns while you work. When formula columns are visible, the button changes to **Hide formulas**. You can also toggle **Actuals Formula** with `⌥⇧A` on Mac or `Alt+Shift+A` on Windows, toggle **Forecast Formula** with `⌥⇧F` on Mac or `Alt+Shift+F` on Windows, and toggle pinned formula columns with `⌘⌥P` on Mac or `Ctrl+Alt+P` on Windows.

## Managing drivers in the table

Use **+ Add driver** to add existing drivers or create a new driver directly in the block.

To insert a driver near another driver, right-click a driver name or open its left-side menu, then select **+ Insert new driver above** or **+ Insert new driver below**. The shortcuts reference lists the keyboard shortcuts for inserting rows.

<Frame>
  <img alt="Driver menu showing insert above and insert below actions" />
</Frame>

To remove a driver from the block, select it and press Backspace, or right-click the driver name and select **Remove from block**.

<Note>
  Removing a driver from the block does not delete it from Runway. It only removes that driver from this table. See [Duplicating, removing & deleting](/concepts/drivers/duplicate-remove-delete) for details.
</Note>

<Frame>
  <img alt="Driver table menu showing remove and delete actions" />
</Frame>

## Formatting drivers

Drivers retain their existing formatting when added to a table on a page. You can adjust color, text style, indentation, precision, and other formatting, but those changes apply globally wherever the driver appears.

For more details, see [Driver formatting](/concepts/drivers/driver-formatting).

## Time period rollups

### Selecting the time period

By default, data in a driver table block is displayed monthly, with each month as a separate column. Use rollups when you want to show quarters, years, or custom ranges.

<Steps>
  <Step title="Open Rollups">
    Click **Customize** in the top-right corner, then select **Rollups**.
  </Step>

  <Step title="Choose a rollup">
    Choose **Monthly**, **Quarterly**, **Annual**, a combined monthly/quarterly/annual view, or **Custom rollup**.
  </Step>

  <Step title="Use custom options when needed">
    Custom rollups include quarter-to-date, half-year-to-date, year-to-date, quarter-to-last-close, half-year-to-last-close, year-to-last-close, and trailing 3, 6, or 12 months.

    <Frame>
      <img alt="Driver table rollup menu" />
    </Frame>
  </Step>
</Steps>

### Selecting the aggregation

Each driver can define how values aggregate into a coarser time period.

<Steps>
  <Step title="Open Roll up by">
    Right-click the driver name and select **Roll up by**.
  </Step>

  <Step title="Choose an aggregation">
    Choose **Sum**, **Average**, **First**, or **Last**.

    <Frame>
      <img alt="Driver rollup aggregation menu" />
    </Frame>
  </Step>
</Steps>

You can also show the **Rollup** property as a column and adjust aggregation directly from the table.

<Steps>
  <Step title="Show the Rollup column">
    Click **Customize** > **Properties**, then enable **Rollup**.
  </Step>

  <Step title="Edit in the table">
    Click the **Rollup** cell for a driver and choose its aggregation method.

    <Frame>
      <img alt="Driver table with Rollup property column visible" />
    </Frame>
  </Step>
</Steps>

## Comparing drivers across scenarios

<Steps>
  <Step title="Open Compare">
    Click **Customize** in the top-right corner.
  </Step>

  <Step title="Choose scenarios">
    Select **Compare**, then choose the scenarios you want to compare.
  </Step>
</Steps>

For more detail, see [Scenarios](/concepts/scenarios#comparing-scenarios).

## Comparing drivers across time periods

In driver tables, you can compare values over time, such as month-over-month, quarter-over-quarter, or year-over-year.

<Steps>
  <Step title="Open time period comparison">
    Click **Customize**, then go to **Compare** > **Time period**.
  </Step>

  <Step title="Choose a comparison window">
    Choose **Previous period**, **3 months ago**, **6 months ago**, or **12 months ago**.
  </Step>

  <Step title="Choose metrics">
    Pick **Value**, **Variance**, **Variance %**, or a combination.
  </Step>

  <Step title="Review the rows">
    Each comparison appears as a new row below the original driver.

    <Frame>
      <img alt="Driver table comparing values across time periods" />
    </Frame>
  </Step>
</Steps>

## Drivers table FAQ

<Accordion title="Can time period comparisons be displayed as columns instead of rows?" icon="sparkles">
  No. Time period comparisons are displayed as rows.
</Accordion>

## What's next

* [Charts block](/concepts/pages/charts-block)
* [Driver formatting](/concepts/drivers/driver-formatting)
* [Keyboard shortcuts](/get-started/keyboard-shortcuts)


# Pages basics
Source: https://runway-docs.cfo.ai/concepts/pages/pages-basics

Pages are a flexible and fully customizable canvas where you can bring different elements from across your model together in one place. Whether you're creating an investor report or collaborating with department heads, pages are the perfect tool for the job.

## Creating a page

To create a new page, follow these steps:

1. Click the **+** next to any section, model, database, or another page. This would allow you to create a page nested within where you clicked on the + button.
2. Type a name for your page and, optionally, change the icon.

<img alt="Create Page" />

## Adding a block to a page

Now that you have a blank page, you can start building content by adding **blocks**.

Type **/** to access block options:

* [**Driver charts**](/concepts/pages/charts-block) – Visualize relevant drivers from anywhere in Runway as charts. Choose from various chart types, including **line, column, stacked, combo, waterfall, and value charts**.
* [**Driver table**](/concepts/pages/drivers-table-block) – Display a subset of drivers in a tabular format.
* [**Database table**](/concepts/pages/database-block) – Bring any existing database into a page. You can **apply filters** to show only the relevant data.
* [**Plan timeline**](/concepts/plans#surfacing-plans-in-pages) – Create a timeline of your Plans and apply filters to limit which ones appear on your page.
* [**Text**](/concepts/pages/text-media-block#text-block) – Add **text** anywhere on the page. You can also reference driver values by typing **@**, followed by the driver name, and selecting **Value on date.** Runway keeps these values updated automatically.
* [**Image**](/concepts/pages/text-media-block#image-block) – Upload an image directly or embed one from a URL.
* [**Video**](/concepts/pages/text-media-block#video-block) – Upload a video file or embed videos from **Loom, YouTube,** or other links.

<img alt="New Block" />

You can **switch between a Driver chart block and a Driver table block** at any time.

To do this, click the **six-dot button** on the left of the block, then select **Turn into table** or **Turn into chart.**

<img alt="Turn To Table" />

## Arranging blocks

Pages are designed to be **flexible**, allowing you to structure content in a way that best tells your story and organizes information effectively.

Drag a block using the **six-dot button** on the left to move it **before, after, or next to** another block.

<img alt="Drag Blocks" />

If you need to create a new block similar to an existing one, you can duplicate it instead of starting from scratch. Click the **six-dot button** on the left of the block, then select **Duplicate block**.

<img alt="Duplicating Blocks" />

You can quickly **move a block to a different page** by dragging it and dropping it onto the target page in the sidebar.

<img alt="Move Block To Page" />

### Managing a page

To **rename, change the icon, duplicate, or delete** a page, click the **three-dot button** next to its name in the **sidebar** and select the appropriate option.

<img alt="Manage Page" />

You can also rename or change the icon by clicking on the icon or name in the page header.

<img alt="Rename In Page" />

Additionally, you can **delete** or **rename** a page by clicking the **three-dot menu** in the top-right corner of the page.

## Pages FAQ

<Accordion title="Can I export a page?">
  You can export specific blocks from a page:

  * **Driver table, Driver chart, and Database blocks** – Click the **six-dot menu** on the left of the block and select **Export to CSV.**
  * **Driver chart block** – Right-click on the chart, click **Download,** and save it as a **PNG.**

  While Runway does not currently support exporting a full page as a **PDF**, some customers use **browser extensions** like [GoFullPage](https://gofullpage.com/) to capture and save entire pages.
</Accordion>


# Text & media block
Source: https://runway-docs.cfo.ai/concepts/pages/text-media-block

In addition to chart blocks, driver table blocks, and database blocks, which let you bring different parts of your model together on a single page, you can also use text, image, and video blocks to add context and strengthen the narrative of your page.

## Text block

Text blocks are **simple and intuitive** — just start typing in any blank space. That’s it!

To insert a new text block **between existing blocks**, click the `+` button on the left of the top block where you want to add text, then select **Text**.

<img alt="Add Block Below" />

You can format your text in various ways:

* **Headings** → Choose from `H1`, `H2`, or `H3`:
  * Use the toolbar or **markdown shortcuts** (`#` for H1, `##` for H2, `###` for H3).
* **Text styles** → Apply **bold**, *italic*, underline, or ~~strikethrough~~.
* **Lists** → Create **bullet points** or **numbered lists**.
* **Hyperlinks** → Add links to external content for additional context.
* **Code blocks** → Type triple backticks (` ``` `) or triple tildes (`~~~`) followed by a space to create a code block for displaying formatted code snippets.

<img alt="Text Block" />

## Image block

To add visuals from outside Runway, use an image block. Simply type `/` to open the block menu and select **Image**.

You can then:

* **Upload an image** from your computer.
* **Embed an image URL** to display an external image.

<img alt="Image Block" />

Once the image is uploaded, you can **resize** it and adjust its **alignment** to **left, center, or right** for better positioning on the page.

<img alt="Image Block Align" />

## Video block

Video blocks work similarly to image blocks. Select **Video** from the block creation menu, then:

* **Upload a video file** from your computer.
* **Embed a link** from **Loom, YouTube, or Vimeo.**


# Plans
Source: https://runway-docs.cfo.ai/concepts/plans

Plans connect strategic initiatives to model changes, so you can see why a value changed and what business action caused the impact.

Plans tag model changes to initiatives. Use them when a hardcoded adjustment, headcount change, or timing shift should stay connected to the business reason behind it.

## Modifying forecasts and tagging plans

You can tag changes to time series values in a driver table, database, or driver detail view. This is useful when a forecast formula is mostly right, but a specific initiative changes one or more months.

<Steps>
  <Step title="Select a forecast value">
    Select a value after your [last close](/concepts/last-close).
  </Step>

  <Step title="Edit the value">
    Edit the cell directly. You can replace the forecasted value, clear it, or use `+` or `-` to add an adjustment on top of the formula value.

    <Frame>
      <img alt="Forecast value edited and tagged to a plan" />
    </Frame>
  </Step>

  <Step title="Add multiple adjustments when needed">
    If multiple initiatives affect the same cell, add multiple adjustments so each can be tagged to a different plan.

    <Frame>
      <img alt="Multiple plan adjustments stacked on one cell" />
    </Frame>
  </Step>

  <Step title="Tag the plan">
    Click **Tag plan** and choose the plan for each adjustment.
  </Step>

  <Step title="Review the cell">
    Cells with plan adjustments show an underline. Hover over the cell to see which plans are applied.
  </Step>
</Steps>

<Info>
  If you modify a cell without tagging it, Runway assigns the change to the **Default Plan**. You can tag it later from the cell editor.
</Info>

<Tip>
  To tag multiple cells with the same plan at once, select them together, then click **Tag plan**. See [Keyboard shortcuts](/get-started/keyboard-shortcuts) for related editing shortcuts.
</Tip>

<Frame>
  <img alt="Plan underline on cells with plan adjustments" />
</Frame>

## Connecting an employee's start date to a plan

If you work in an Employees database generated from a supported [HRIS integration](/integrations/hris/rippling), it includes a **Start Date** column by default.

* Synced employees with a future **Start Date** are automatically tagged as part of your **Default Plan**.
* Manually added rows for future hires are also included in **Default Plan** when their **Start Date** is in the future.

<Frame>
  <img alt="Employees database row connected to Default Plan through start date" />
</Frame>

Use plan groups to move work out of **Default Plan** and into more meaningful initiatives.

<Info>
  Deleting a plan that originates from a new database row clears the **Start Date** for that object, but the row itself is not deleted.
</Info>

## Organizing plans

Group related plans together when the list gets long.

<Steps>
  <Step title="Open Plans">
    Navigate to **Plans** from the sidebar.
  </Step>

  <Step title="Select related plans">
    Select the plans you want to group.
  </Step>

  <Step title="Group them">
    Right-click the selection and choose **Group**. Enter a name and press Enter. The shortcuts reference lists the keyboard shortcut for grouping.

    <Frame>
      <img alt="Plans grouped in the Plans page" />
    </Frame>
  </Step>
</Steps>

## Surfacing plans in pages

[Pages](/concepts/pages/pages-basics) let you bring model context onto a shared canvas. A Plan timeline block shows plans in the current [scenario](/concepts/scenarios).

<Steps>
  <Step title="Add the block">
    Type **/** and select **Plan timeline**.
  </Step>

  <Step title="Filter plans">
    Apply filters to show the plans relevant to the page. You can filter by plan name, model, and more.
  </Step>

  <Step title="Order the timeline">
    Drag and drop plans to reorder them.
  </Step>
</Steps>

Plan timelines work well with [chart blocks](/concepts/pages/charts-block) that visualize upstream metrics affected by those plans.

Once plans are on a timeline, you can:

* Adjust plan values for a single month while leaving other months unchanged.
* Push a plan forward or backward in time.
* Stretch a plan across multiple months. If the plan uses `=`, the value repeats across all months. If it uses `+` or `-`, the total impact is distributed.

<Frame>
  <img alt="Plan timeline block on a page" />
</Frame>

## Marking KPI drivers

Mark important drivers as KPIs when you want them to stand out in formulas and plan detail views.

<Steps>
  <Step title="Open the driver menu">
    Right-click a driver or open its row menu.
  </Step>

  <Step title="Set the KPI">
    Select **Set as KPI**.
  </Step>

  <Step title="Check the indicator">
    KPI drivers show an indicator with the tooltip **This driver is a KPI**.
  </Step>
</Steps>

Plan detail views include KPI drivers in **KPIs impacted by plan** when the plan affects them.

## Accessing a plan's details

<Steps>
  <Step title="Open details">
    Click the upward arrow next to a plan's name on the timeline.
  </Step>

  <Step title="Review impacted items">
    The detail view shows drivers and database rows impacted by that plan.
  </Step>

  <Step title="Adjust KPIs">
    Drivers marked as KPIs also appear, so you can adjust the plan and immediately see the impact.

    <Frame>
      <img alt="Plan details view showing impacted drivers" />
    </Frame>
  </Step>
</Steps>

## Deleting a plan

To delete a plan permanently, right-click its name and select **Delete**. In the details view, you can also click the delete icon.

<Frame>
  <img alt="Plan timeline delete action" />
</Frame>

You can also delete the impact of a plan on a single driver. Right-click the driver's name in the timeline and select **Delete**.

<Frame>
  <img alt="Delete plan impact from a single driver" />
</Frame>

## Plans FAQ

<Accordion title="Could moving my Last Close date forward delete my plans?">
  No. Plans remain available in Runway after you move last close.

  Whether a plan affects a visible cell depends on what else applies to that month. Runway checks hardcoded values, actuals formulas, integration data, plan hardcodes, and forecast formulas according to the formula and last-close rules for that driver.
</Accordion>

## What's next

* [Scenarios](/concepts/scenarios)
* [Budget vs. actuals](/guides/modeling/bva)
* [Drivers basics](/concepts/drivers/drivers-basics)


# Scenarios
Source: https://runway-docs.cfo.ai/concepts/scenarios

Scenarios are parallel versions of your model where you can test assumptions, compare outcomes, and merge approved changes back to Main.

Scenarios let you safely explore changes without immediately changing Main. Use them for budgets, hiring plans, downside cases, board scenarios, or any work where you want to compare assumptions before making them official.

## Main vs. draft scenarios

Your **Main** scenario is your live, official model. To protect it from accidental changes, Runway automatically creates a draft scenario when you make data edits in Main.

Once in draft, edits remain local. They do not affect Main or another scenario unless they are merged.

<Frame>
  <img alt="Draft scenario flow showing edits staged before merge" />
</Frame>

### What counts as a data edit?

These actions create a draft when performed in Main. In a non-Main scenario, the impact stays scoped to that scenario until a user with merge access merges it into Main.

* **Drivers:** Creating, renaming, deleting, editing formulas, modifying values, moving drivers, adding or removing drivers from blocks, marking KPIs, and changing formatting.
* **Models or databases:** Creating or deleting models or databases, adding or removing database rows, editing formulas, modifying cells, or changing database schema.
* **Pages:** Creating, renaming, deleting, reordering pages, creating or deleting blocks, editing blocks, or creating and updating sidebar sections.

### What does not count?

The following changes apply directly to Main and to scenarios with automatic updates enabled:

* Table view changes such as filters, sorts, groups, visible columns, and column width.
* Adding, editing, or removing integration credentials.
* Adding, editing, or removing integration queries and configuration.

### How to tell you're in a draft scenario

Look for the `DRAFT` label in the scenario name.

<Frame>
  <img alt="Scenario name with Draft label" />
</Frame>

### Managing a draft scenario

When working in a draft scenario, available actions depend on your [permissions](/guides/sharing/permissions):

* **Save draft as scenario...** creates a standalone scenario for your edits.
* **Compare & merge** compares your edits with Main and merges them if you have merge access.
* **Discard draft** removes the draft edits and returns you to Main.

<Frame>
  <img alt="Draft scenario menu with save, compare, and discard actions" />
</Frame>

## Creating a new scenario

<Steps>
  <Step title="Open scenarios">
    Open the scenarios list in the top-left area of Runway.
  </Step>

  <Step title="Create the scenario">
    Click **+ New scenario**.
  </Step>

  <Step title="Name it">
    Give the scenario a name and choose an icon or emoji.
  </Step>

  <Step title="Start editing">
    The new scenario starts as a copy of Main. Edits you make affect only that scenario unless merged.

    <Frame>
      <img alt="Create scenario dialog" />
    </Frame>
  </Step>
</Steps>

<Note>
  You can also save a draft as a scenario using **Save draft as scenario...**.
</Note>

## Duplicating scenarios

Use **Duplicate scenario** when you want a new scenario that starts from an existing scenario's assumptions.

Duplicating a normal scenario creates a copy named `{Name} (Copy)` that keeps pulling updates from Main. Duplicating a locked scenario creates a locked copy. The menu item changes to **Duplicating...** while Runway creates the copy.

Duplication is not available on Main, on drafts, or when you do not have scenario-creation access. See [Permissions](/guides/sharing/permissions) for access details.

## Pulling updates from Main

By default, scenarios inherit non-conflicting updates from Main. To prevent Main updates from affecting a scenario, open scenario settings and set **Pull updates from Main** to **Disabled**.

<Frame>
  <img alt="Scenario setting with Pull updates from Main disabled" />
</Frame>

To resume updates, set **Pull updates from Main** back to **Automatic**. Re-enabling automatic updates can pull in existing and future non-conflicting changes from Main, so review the scenario after switching it back.

## Locked scenarios

Locked scenarios preserve a version of the model so it cannot be edited accidentally.

You can create locked scenarios from two places:

* On Main, use **Save draft as scenario...** to save the draft as a scenario.
* In the activity history pane, use **Save as locked scenario** from a change's overflow menu.

Locked scenarios are not editable. When managing access, the share sheet can show this notice: **To manage access in locked scenarios, please switch to the locked scenario and then open the share sheet again.**

## Scenario settings

In the scenarios list, open settings next to a scenario name to adjust:

* **Renaming and icon:** Update the scenario name or emoji/icon.
* **Pull updates from Main:** Choose **Automatic** or **Disabled**.
* **Allow Merging:** Allow or block merging into Main.
* **Editing:** Control whether edits can be made.
* **Who can view:** Control who can access the scenario.
* **Copy link:** Copy a link to the scenario.
* **Delete:** Remove a scenario you no longer need.

<Frame>
  <img alt="Scenario settings menu" />
</Frame>

## Merging scenarios

Scenarios work by layering edits on top of Main. Merging applies the scenario's selected changes to Main. Merge access is controlled by permissions; see [Permissions](/guides/sharing/permissions).

<Steps>
  <Step title="Open the scenario">
    Navigate to the scenario you want to merge.
  </Step>

  <Step title="Compare with Main">
    Click **Compare and merge** to compare the scenario against Main.
  </Step>

  <Step title="Review and confirm">
    Review the changes, then confirm the merge if the scenario should update Main.

    <Frame>
      <img alt="Compare and merge button in a scenario" />
    </Frame>
  </Step>
</Steps>

If you cannot merge a scenario, share it with someone who has the right access. Open the scenario from the scenarios list and use **Copy link**.

<Frame>
  <img alt="Scenario menu showing Copy link" />
</Frame>

### How merging affects other scenarios

Each scenario keeps its own edits until those edits are merged.

For example, if two people edit Driver A in separate drafts, each draft keeps its own version. If one draft merges first, the other draft still keeps its own Driver A edit until it is merged or discarded. When the second draft later merges, its Driver A change can overwrite the first merged version in Main.

If a scenario has **Pull updates from Main** set to **Automatic**, non-conflicting changes merged into Main can appear in that scenario. Its own scenario-specific edits remain local.

## Comparing scenarios

### Tabular comparison in pages and models

<Steps>
  <Step title="Open a model or driver table">
    Open a model or create a **Driver table** block on a page.
  </Step>

  <Step title="Add drivers">
    Add the drivers you want to compare across scenarios.
  </Step>

  <Step title="Open Compare">
    Click **Customize**, select **Compare**, then choose the scenarios.
  </Step>

  <Step title="Review variance">
    The default comparison view includes variance rows. You can also add or remove **Variance** and **Variance %** from the same menu.
  </Step>

  <Step title="Choose layout">
    Show scenarios as rows or columns.

    <Frame>
      <img alt="Driver table comparing scenarios with variance rows" />
    </Frame>
  </Step>
</Steps>

Variance color follows the driver's comparison-color setting. To reverse colors for a driver, set its goal direction, such as lower is better for expenses.

<Frame>
  <img alt="Driver comparison color setting" />
</Frame>

When a block compares scenarios as rows, edits made in a scenario's comparison row write into that scenario without switching the page's active scenario. Variance and variance-% rows are computed and are not editable.

### Graphical comparison in pages

<Steps>
  <Step title="Create a chart">
    Create a **Driver charts** block on a page.
  </Step>

  <Step title="Add drivers">
    Add the drivers you want to compare.
  </Step>

  <Step title="Choose scenarios">
    Click **Compare**, then choose the scenarios.

    <Frame>
      <img alt="Chart comparing a driver across scenarios" />
    </Frame>
  </Step>
</Steps>

## FAQ

<Accordion title="Can I re-enable Pull updates from Main after disabling it?">
  Yes. Switch **Pull updates from Main** back to **Automatic**. Runway will pull in non-conflicting existing and future changes from Main, so review the scenario after re-enabling it.
</Accordion>

<Accordion title="Can I duplicate a locked scenario?">
  Yes. **Duplicate scenario** preserves the locked state, so the copy is also locked.
</Accordion>

## What's next

* [Plans](/concepts/plans)
* [Budget vs. actuals](/guides/modeling/bva)
* [Permissions](/guides/sharing/permissions)


# Navigating Runway
Source: https://runway-docs.cfo.ai/concepts/sidebar

Use Runway navigation, search, sidebar sections, templates, unlisted drivers, product updates, and activity history to move through your workspace.

Runway navigation combines global search, a customizable sidebar, and activity history. Use these surfaces to jump to work, organize pages and models, recover drivers that are not on any page, and inspect recent changes.

## Search

Press `⌘K` (`Ctrl+K` on Windows) to open search. The search field uses the placeholder **Search Runway** and returns results in **Pages**, **Drivers**, and **Databases**. Use the arrow keys to select a result, then press Enter to jump to it.

## Default sidebar structure

When you first start using Runway, the sidebar includes:

* **Three customizable sections**: **Models, Databases, Pages.** You can rename, reorder, or delete these sections.
* **Static items** such as **Integrations**, **Plans**, **Templates**, **Unlisted Drivers**, and **What's new?**.

  <img alt="Default Sidebar" />

## Sections for better organization

We recommend structuring the sidebar with **sections** to group related models, databases, and pages. For example, you might have:

* A section for **department pages**
* Another for **P\&L reports** at different levels of granularity
* A section for **executive reporting**

To create a new section, click the **+** button in the **top-right** of the sidebar, then give it a **name** and **icon**. It will appear as the first section.

<img alt="Created Section" />

You can **move** a section by dragging it to the right spot. To **rename or delete** a section, click the **•••** (more options) button next to its name.

<img alt="Rename Delete Section" />

To add content within a section, click the **+** button next to the section name. Any **model, database, or page** created this way will be added to that section.

<img alt="Create Page" />

You can also **move existing items** into a section by dragging them. Additionally, you can **nest** models, databases, or pages under each other by dragging them beneath one another.

You can expand and collapse all elements in the sidebar in bulk with `Cmd+Click` or `Shift+Click` on any section in the sidebar, similar to Excel's hide / show group behavior.

## Icons for easier scanning

Every **section, model, database, or page** in Runway can have an **emoji or icon** to make it easier to recognize at a glance.

* Runway offers **1,000+ icons** in nine colors.
* Emojis also support **skin tone variations**.

To change an icon for an existing section, model, database, or page, click the **•••** (more options) button next to its name and select **"Rename"**. From there, you can edit the name and choose a new icon.

When selecting an icon, you can switch between **icons and emojis** at the top of the selection panel and use **search** to find the right one. Icons also allow you to **customize colors**.

<img alt="Icons Picker" />

## Integrations

Use **Integrations** to open connected data sources or browse new ones. Choose **Browse all integrations** from the sidebar when you want to see the live in-app directory.

## Templates

Use **Templates** to find reusable page templates that can be added to Runway when they are available to your workspace.

## Unlisted Drivers

Drivers that are not on any page live in **Unlisted Drivers**. This is where you can recover drivers that were removed from a page but not deleted. For the difference between removing and deleting drivers, see [Duplicating, removing & deleting](/concepts/drivers/duplicate-remove-delete).

## What's new?

Use **What's new?** to open [Runway product updates](https://runway.cfo.ai/product-updates).

## Activity history

Click the clock icon labeled **History**, then open the **Activity** pane to review recent changes. Activity history groups changes by user and includes timestamps.

Use **Exclude updates from Runway** when you want to hide system-generated updates from the list. From a change's overflow menu, use **Save as locked scenario** to snapshot the model at that point. See [Scenarios](/concepts/scenarios#locked-scenarios) for how locked scenarios work.

## FAQ

<Accordion title="Where do removed drivers go?">
  Drivers that are removed from a page but not deleted appear in **Unlisted Drivers**.
</Accordion>

<Accordion title="Is search a command runner?">
  No. Search is for navigation. It helps you jump to pages, drivers, and databases.
</Accordion>

<Accordion title="Can I organize pages into custom sections?">
  Yes. Create sections from the sidebar, then drag pages, models, and databases into them.
</Accordion>

## What's next

* [Pages basics](/concepts/pages/pages-basics)
* [Duplicating, removing & deleting](/concepts/drivers/duplicate-remove-delete)
* [Scenarios](/concepts/scenarios)


# Domain migration FAQ
Source: https://runway-docs.cfo.ai/domain-migration

Everything you need to know about our domain change from runway.com to cfo.ai.

We're moving from **runway.com** to **cfo.ai**. This page answers common questions about what's changing, when, and what you need to do.

## About the change

<AccordionGroup>
  <Accordion title="Is Runway changing its name to CFO.ai?">
    No. Our **legal name is not changing** — we are still Runway. Only our **brand identity and domains** are moving to CFO.ai.

    You'll see `cfo.ai` in URLs, email addresses, and some visual branding, but the company, product, contracts, and team are the same.
  </Accordion>
</AccordionGroup>

## What's changing

<AccordionGroup>
  <Accordion title="Which URLs are moving?">
    | Old (runway.com) | New (cfo.ai)       |
    | ---------------- | ------------------ |
    | app.runway.com   | v2.cfo.ai          |
    | runway.com       | runway.cfo.ai      |
    | docs.runway.com  | runway-docs.cfo.ai |
  </Accordion>

  <Accordion title="Will my bookmarks and saved links still work?">
    No. **Update any bookmarks or shared links to [<u>v2.cfo.ai</u>](http://v2.cfo.ai) domains before July 15th.**
  </Accordion>

  <Accordion title="Is Runway changing its name to CFO.ai?">
    Our **brand identity and domains** are moving to CFO.ai, but our legal name is not changing.

    You'll see `cfo.ai` in URLs, email addresses, and some visual branding, but the company, product, contracts, and team are the same.
  </Accordion>

  <Accordion title="Are email addresses changing?">
    Team email addresses are moving to @cfo.ai. Mail sent to @runway.com addresses will continue to be delivered during the transition.

    You may start to see support and account emails arrive from `@cfo.ai` senders. These are legitimate. Should you need support, please reach out to [support@cfo.ai](mailto:support@cfo.ai) or to [ar@cfo.ai](mailto:ar@cfo.ai) for contract questions.
  </Accordion>
</AccordionGroup>

## What you need to do

<AccordionGroup>
  <Accordion title="Do I need to do anything?">
    Update any saved bookmarks or shared links to the [v2.cfo.ai](http://v2.cfo.ai). This will look something like v2.cfo.ai/.
  </Accordion>

  <Accordion title="Do I need to update my SSO configuration?">
    If you use SSO (Okta, Google Workspace, Azure AD, etc.) to log in to runway.com, there is no additional action needed to maintain your login access.
  </Accordion>

  <Accordion title="Do I need to update my firewall or allowlist?">
    If your organization uses firewall, proxy, DNS, or other network security controls, please ask your IT team to allowlist the [<u>cfo.ai</u>](http://cfo.ai) domain before July 15th so your access continues without interruption.

    Recommended entries:

    * \*.cfo.ai
    * v2.cfo.ai
    * runway.cfo.ai
    * runway-docs.cfo.ai
  </Accordion>

  <Accordion title="Do I need to update webhooks or API integrations?">
    API requests to api.runway.com will require updating your base URL to [https://runway-api.cfo.ai](https://runway-api.cfo.ai).

    Webhook payloads sent from Runway will begin using cfo.ai in their signing domain. If you validate the sender host, update your allowlist to include cfo.ai.
  </Accordion>
</AccordionGroup>

## Security & trust

<AccordionGroup>
  <Accordion title="How do I know an email from @cfo.ai is really from Runway?">
    Legitimate emails from us are sent from @cfo.ai addresses and are authenticated with SPF, DKIM, and DMARC aligned to cfo.ai.

    We will never ask for your password, MFA codes, or API keys over email. If in doubt, contact [support@cfo.ai](mailto:support@cfo.ai) or within your shared Slack channel with us.
  </Accordion>

  <Accordion title="Is data or account access affected?">
    No. Your account, data, integrations, and permissions are unchanged. The migration is a domain change only — no data is being moved between systems as part of this.
  </Accordion>
</AccordionGroup>

## Still have questions?

Reach out to our team at [support@cfo.ai](mailto:support@cfo.ai) and we'll help you through the transition.


# Glossary
Source: https://runway-docs.cfo.ai/get-started/glossary

Get familiar with the key terms you will encounter throughout Runway.

### **Dimension**

A data type in Runway—like numbers or dates—used to categorize data. Common examples:

* **GL dimensions**: `Class`, `Account`, `Account Type`, `Vendor`
* **HRIS dimensions**: `Role`, `Department`, `Location`
* **CRM dimensions**: `Region`, `Pipeline Stage`

**Dimension values** are the options within a dimension (e.g. `Marketing`, `Engineering`, `Sales` for the `Department` dimension).

[Learn more about dimensions →](/concepts/dimensions/dimensions-basics)

### Driver

A time series that tracks numerical or date-based values over time. Drivers come in these types:

* **Unsegmented driver** – Typically created in a [driver table on a page](/concepts/pages/drivers-table-block) or [model](/concepts/models/models-basics) (e.g. `Burn`, `Runway`).
* **Segmented driver** – Broken down by one or more dimensions. Most often created in a database (e.g. `Amount [Account][Class]`).
  * **Segment of a driver** – A single portion of a segmented driver (e.g. `Amount [2300 — Payroll Liabilities][Engineering]`).

[Learn more about driver basics →](/concepts/drivers/drivers-basics)

[Learn more about driver segmentation →](/concepts/dimensions/segmenting-drivers)

### Databases

Where all your structured data lives—both integration-synced and manually created.

* **Integration-created** – Pulled from [systems](/integrations/intro-to-integrations) like your GL, HRIS, or CRM.
* **User-created** – Built from scratch for modeling assumptions, rollups, or [lookups](/guides/modeling/lookups).

[Learn more about databases →](/concepts/databases/databases-basics)

### Models

Tables of related drivers for lightweight modeling and grouping.

[Learn more about models →](/concepts/models/models-basics)

### Pages

A flexible canvas for combining drivers, charts, and data views to tell a story, report, or collaborate.

**Block** – Each content element on a page is a block, such as a [driver table](/concepts/pages/drivers-table-block), [chart](/concepts/pages/charts-block), [database](/concepts/pages/database-block), [plan timeline](/concepts/plans#surfacing-plans-in-pages), or [text, image, and video block](/concepts/pages/text-media-block).

[Learn more about pages →](/concepts/pages/pages-basics)

### Section

Used to organize your pages, models, and databases in the sidebar.

[Learn more about sidebar sections →](/concepts/sidebar)

### Scenario

A version of your model. Used for simulating various scenarios, testing new ideas, and running [BvA](/guides/modeling/bva). Scenarios can stay in sync with your Main scenario or diverge completely.

[Learn more about scenarios →](/concepts/scenarios)

### Plans

Used to tag forecast overrides with real-world business context (e.g. hiring plans, initiatives, contracts). Helps bridge roadmap and financial data.

[Learn more about plans →](/concepts/plans)

### Role

Determines a user's default workspace access. See the current role list and capability matrix in [Permissions](/guides/sharing/permissions) and [Roles and access](/reference/roles-and-access).

[Learn more about roles →](/guides/sharing/permissions)

### Access level

In addition to having a role, each user can have different access levels for individual resources in Runway.

[Learn more about access levels →](/guides/sharing/permissions#access-levels)


# How Runway fits together
Source: https://runway-docs.cfo.ai/get-started/how-runway-fits-together

Understand how drivers, dimensions, databases, models, and pages work together in Runway.

Runway is easiest to learn when you treat it as a flow: data comes in, gets structured, becomes modeled numbers, appears on pages, and can be safely forked into scenarios for planning.

```mermaid theme={null}
flowchart LR
  integrations[Integrations] --> databases[Databases]
  databases --> dimensions[Dimensions]
  dimensions --> drivers[Drivers]
  databases --> drivers
  drivers --> models[Models]
  models --> pages[Pages]
  pages --> scenarios[Scenarios]
  scenarios --> plans[Plans]
  lastclose[Last close] --> drivers
```

[Integrations](/integrations/intro-to-integrations) bring source data into Runway. Accounting systems, HRIS systems, revenue systems, CSV uploads, sheets, and warehouses are all ways to get business data into the workspace. Integrations write actuals into Runway up to [last close](/concepts/last-close), which is the cutoff between closed historical months and future forecast months.

[Databases](/concepts/databases/databases-basics) are where that source data becomes usable. A database is made of rows of real things: transactions, employees, deals, accounts, vendors, customers, or records you create manually. Some databases come directly from an integration query. Others roll up another database into a cleaner planning grain.

A good database keeps detail available without forcing every report to show that detail. For example, a transaction database can keep every source row, while a rollup database groups those rows by account, department, and month. That lets finance teams inspect the original data when something looks wrong, but model from the summary level that matches the planning decision.

[Dimensions](/concepts/dimensions/dimensions-basics) classify those rows. Department, region, account, entity, employee, and pipeline stage are common dimensions. Dimensions are what let one database support many views of the same data. A transaction can belong to an account and a department; a driver can then be segmented by those dimensions instead of being copied into separate spreadsheet rows.

[Drivers](/concepts/drivers/drivers-basics) are the numbers and dates you model over time. Revenue, headcount, salary expense, cash, contract end date, and quota are drivers. A driver can be unsegmented, or it can be segmented by dimensions so each department, account, or employee has its own time series. Drivers are the values that formulas reference, charts visualize, and plans change.

Segmentation is the bridge between database detail and driver-level planning. One Revenue driver can be segmented by department, region, or account instead of being duplicated for every slice of the business. Formulas can then reference the total driver, a specific segment, or a database-backed input, depending on whether the model needs a company-level number or a detailed operational assumption.

[Models](/concepts/models/models-basics) organize drivers. They are useful when you want a focused working space for a part of the business, such as revenue, headcount, expenses, or cash. [Pages](/concepts/pages/pages-basics) present the model to people: charts, driver tables, database tables, text, images, videos, and plan timelines live on pages.

Models vs. pages can be confusing because they overlap. The honest distinction is that models organize drivers for modeling work, while pages present drivers and context for reporting, collaboration, and repeated workflows. Runway is making these surfaces feel closer together on purpose, so you can move from building to explaining without rebuilding the same content.

[Scenarios](/concepts/scenarios) let you fork the whole world safely. A scenario can change formulas, values, pages, models, databases, and plans without immediately changing Main. That makes scenarios the right place to test a hiring plan, a new budget, or a board-case forecast before deciding what should become official.

[Plans](/concepts/plans) tag changes to initiatives. Instead of hardcoding a value and losing the business reason, you can connect the change to a hiring plan, a product launch, a cost reduction, or another initiative. Plans then show where assumptions live and how they affect the model.

The last key idea is [actuals vs. forecast](/guides/modeling/forecasting-with-closed-actuals). Integrations write actuals through last close. After last close, formulas take over. That boundary lets Runway keep historical months tied to source systems while future months stay editable for planning.

## What's next

* [Quickstart: build your first model](/get-started/quickstart)
* [Databases basics](/concepts/databases/databases-basics)
* [Scenarios](/concepts/scenarios)


# Welcome to Runway
Source: https://runway-docs.cfo.ai/get-started/introduction

Learn what Runway is, how its building blocks fit together, and where to start.

<img alt="Runway Docs Intro" />

Runway is where your business gets modeled, planned, and understood — by everyone, not just the finance team. It connects to the systems you already run on, turns them into a living model of your business, and gives your whole team one place to plan against it.

**New to Runway?** Start here:

<Steps>
  <Step title="Quickstart">
    [Build your first working model](/get-started/quickstart) in about 30 minutes.
  </Step>

  <Step title="How Runway fits together">
    Learn [the five building blocks](/get-started/how-runway-fits-together) (drivers, dimensions, databases, models, pages) and how they relate.
  </Step>

  <Step title="Connect your data">
    [Bring in accounting, HRIS, and revenue data](/integrations/intro-to-integrations).
  </Step>

  <Step title="Share it">
    [Invite your team](/guides/sharing/adding-users) and control what they see.
  </Step>
</Steps>

## Learn the concepts

<CardGroup>
  <Card title="Drivers" icon="chart-mixed-up-circle-dollar" href="/concepts/drivers/drivers-basics">
    The metrics and assumptions that power your model
  </Card>

  <Card title="Databases" icon="database" href="/concepts/databases/databases-basics">
    Structured data from your systems, ready to model
  </Card>

  <Card title="Dimensions" icon="list" href="/concepts/dimensions/dimensions-basics">
    Slice anything by department, region, product, and more
  </Card>

  <Card title="Models" icon="table" href="/concepts/models/models-basics">
    Organized workspaces for the drivers behind a part of the business
  </Card>

  <Card title="Pages" icon="file" href="/concepts/pages/pages-basics">
    Where models become charts, tables, and narratives
  </Card>

  <Card title="Scenarios" icon="code-branch" href="/concepts/scenarios">
    Safely explore what-ifs without touching the main model
  </Card>

  <Card title="Plans" icon="timeline-arrow" href="/concepts/plans">
    Tag changes to initiatives and see their impact
  </Card>
</CardGroup>

## Let AI do the work

<CardGroup>
  <Card title="Explain Mode" icon="sparkles" href="/ai/explain-mode">
    Ask why any number is what it is
  </Card>

  <Card title="Command Mode" icon="wand-magic-sparkles" href="/ai/command-mode">
    Build charts, pages, and databases by describing them
  </Card>

  <Card title="Connecting AI tools" icon="plug" href="/ai/connecting-ai-tools">
    Use Runway from Claude and other AI tools via MCP
  </Card>
</CardGroup>

## Follow a guide

<Accordion title="Modeling guides">
  * [Lookups](/guides/modeling/lookups)
  * [FX rate](/guides/modeling/fx-rate)
  * [Seasonal forecasting](/guides/modeling/seasonal-forecasting)
  * [Propagating sparse data](/guides/modeling/propagating-sparse-data)
  * [Headcount planning](/guides/modeling/headcount-planning)
  * [Prorated salaries](/guides/modeling/prorated-salaries)
  * [Quota attainment](/guides/modeling/quota-attainment)
  * [Cohorts modeling](/guides/modeling/cohorts)
  * [Budget vs. actuals](/guides/modeling/bva)
  * [Revenue recognition](/guides/modeling/revenue-recognition)
  * [Commissions](/guides/modeling/commissions)
  * [Building a P\&L](/guides/modeling/building-p-and-l)
  * [Ranked Lists](/guides/modeling/ranked-lists)
</Accordion>

<Accordion title="Sharing & collaboration">
  * [Adding users](/guides/sharing/adding-users)
  * [Permissions](/guides/sharing/permissions)
  * [Share links & guest access](/guides/sharing/share-links)
  * [Groups](/guides/sharing/groups)
  * [SSO & authentication](/guides/sharing/sso)
  * [Data anonymization](/guides/sharing/data-anonymization)
  * [Comments](/guides/sharing/comments)
</Accordion>

Questions or feedback? Email [support@cfo.ai](mailto:support@cfo.ai). Customers also have a dedicated CXM.


# Keyboard shortcuts
Source: https://runway-docs.cfo.ai/get-started/keyboard-shortcuts

Reference keyboard shortcuts for navigation, editing, formulas, driver grids, and page actions in Runway.

Use keyboard shortcuts to move through Runway faster when you are editing formulas, driver grids, pages, and scenarios.

The tables below use the shortcut registry from the Runway webapp. `Cmd+Shift+S` has two contexts: it strikes selected text in text editing surfaces and reveals the current page in the sidebar in grid and page contexts.

<Tabs>
  <Tab title="Mac">
    ### Navigation

    | Action                                                      | Shortcut | Registered hotkeys                  |
    | ----------------------------------------------------------- | -------- | ----------------------------------- |
    | Open search                                                 | `⌘ K`    | `Cmd+K, Ctrl+K`                     |
    | Open the selected item's detail view                        | `⌘ ⇧ ⏎`  | `Cmd+Shift+Enter, Ctrl+Shift+Enter` |
    | Move to the previous item in the detail pane                | `⌃ ⇧ K`  | `Ctrl+Shift+K`                      |
    | Move to the next item in the detail pane                    | `⌃ ⇧ J`  | `Ctrl+Shift+J`                      |
    | Move to the next cell                                       | `Tab`    | `Tab`                               |
    | Move to the previous cell                                   | `⇧ Tab`  | `Shift+Tab`                         |
    | Reveal the current page in the sidebar (in grids and pages) | `⌘ ⇧ S`  | `Cmd+Shift+S, Ctrl+Shift+S`         |
    | Move up                                                     | `↑`      | `Up`                                |
    | Move down                                                   | `↓`      | `Down`                              |
    | Move to the top edge of the current region                  | `⌘ ↑`    | `Cmd+Up, Ctrl+Up`                   |
    | Move to the bottom edge of the current region               | `⌘ ↓`    | `Cmd+Down, Ctrl+Down`               |
    | Extend selection up                                         | `⇧ ↑`    | `Shift+Up`                          |
    | Extend selection down                                       | `⇧ ↓`    | `Shift+Down`                        |
    | Extend selection to the top edge of the current region      | `⌘ ⇧ ↑`  | `Cmd+Shift+Up, Ctrl+Shift+Up`       |
    | Extend selection to the bottom edge of the current region   | `⌘ ⇧ ↓`  | `Cmd+Shift+Down, Ctrl+Shift+Down`   |
    | Move left                                                   | `←`      | `Left`                              |
    | Move right                                                  | `→`      | `Right`                             |
    | Move to the left edge of the current region                 | `⌘ ←`    | `Cmd+Left, Ctrl+Left`               |
    | Move to the right edge of the current region                | `⌘ →`    | `Cmd+Right, Ctrl+Right`             |
    | Extend selection left                                       | `⇧ ←`    | `Shift+Left`                        |
    | Extend selection right                                      | `⇧ →`    | `Shift+Right`                       |
    | Extend selection to the left edge of the current region     | `⌘ ⇧ ←`  | `Cmd+Shift+Left, Ctrl+Shift+Left`   |
    | Extend selection to the right edge of the current region    | `⌘ ⇧ →`  | `Cmd+Shift+Right, Ctrl+Shift+Right` |
    | Collapse or expand the sidebar                              | `⌘ /`    | `Cmd+/, Ctrl+/`                     |

    ### Editing & formatting

    | Action                                                             | Shortcut | Registered hotkeys              |
    | ------------------------------------------------------------------ | -------- | ------------------------------- |
    | Delete selected content or remove the selected driver from a block | `⌫`      | `Backspace, Delete`             |
    | Delete the selected driver or item                                 | `⇧ ⌫`    | `Shift+Backspace, Shift+Delete` |
    | Bold selected text                                                 | `⌘ B`    | `Cmd+B, Ctrl+B`                 |
    | Underline selected text                                            | `⌘ U`    | `Cmd+U, Ctrl+U`                 |
    | Italicize selected text                                            | `⌘ I`    | `Cmd+I, Ctrl+I`                 |
    | Strike selected text (in text)                                     | `⌘ ⇧ S`  | `Cmd+Shift+S, Ctrl+Shift+S`     |
    | Undo the latest change                                             | `⌘ Z`    | `Cmd+Z, Ctrl+Z`                 |
    | Redo the latest change                                             | `⌘ ⇧ Z`  | `Cmd+Shift+Z, Ctrl+Shift+Z`     |
    | Redo the latest change on Windows                                  | `⌃ Y`    | `Ctrl+Y`                        |
    | Increase decimal precision                                         | `⌘ .`    | `Cmd+., Ctrl+.`                 |
    | Decrease decimal precision                                         | `⌘ ⇧ .`  | `Cmd+Shift+., Ctrl+Shift+.`     |
    | Select all                                                         | `⌘ A`    | `Cmd+A, Ctrl+A`                 |

    ### Drivers & grids

    | Action                                               | Shortcut | Registered hotkeys                                                   |
    | ---------------------------------------------------- | -------- | -------------------------------------------------------------------- |
    | Indent the selected driver                           | `⌘ ⌥ ]`  | `Cmd+Option+], Ctrl+Option+], Cmd+Alt+], Ctrl+Alt+]`                 |
    | Outdent the selected driver                          | `⌘ ⌥ [`  | `Cmd+Option+[, Ctrl+Option+[, Cmd+Alt+[, Ctrl+Alt+[`                 |
    | Edit the selected cell, or save the active cell edit | `⏎`      | `Enter`                                                              |
    | Open the plan picker in grids                        | `⇧ ⏎`    | `Shift+Enter`                                                        |
    | Toggle drill-in in driver grids                      | `⌘ ⏎`    | `Cmd+Enter, Ctrl+Enter`                                              |
    | Collapse the parent drill-in in driver grids         | `⌘ ⌥ ⏎`  | `Cmd+Option+Enter, Ctrl+Option+Enter, Cmd+Alt+Enter, Ctrl+Alt+Enter` |
    | Duplicate the selected driver                        | `⌘ D`    | `Cmd+D, Ctrl+D`                                                      |
    | Hide the selected drivers or rows                    | `⌘ ⇧ H`  | `Cmd+Shift+H, Ctrl+Shift+H`                                          |
    | Group selected drivers                               | `⌘ G`    | `Cmd+G, Ctrl+G`                                                      |
    | Hide or show driver names                            | `⌥ N`    | `Option+N, Alt+N`                                                    |
    | Hide or show segment attributes                      | `⌥ S`    | `Option+S, Alt+S`                                                    |
    | Toggle driver formatting                             | `⌥ F`    | `Option+F, Alt+F`                                                    |
    | Add selected drill-in drivers to the block           | `⌘ ⇧ B`  | `Cmd+Shift+B, Ctrl+Shift+B`                                          |
    | Insert a driver above the current selection          | `⌘ ⌥ =`  | `Cmd+Option+=, Ctrl+Option+=, Cmd+Alt+=, Ctrl+Alt+=`                 |
    | Insert a driver below the current selection          | `⌘ ⌥ -`  | `Cmd+Option+-, Ctrl+Option+-, Cmd+Alt+-, Ctrl+Alt+-`                 |

    ### Formulas

    | Action                                   | Shortcut | Registered hotkeys                                   |
    | ---------------------------------------- | -------- | ---------------------------------------------------- |
    | Hide or show the Forecast Formula column | `⌥ ⇧ F`  | `Option+Shift+F, Alt+Shift+F`                        |
    | Hide or show the Actuals Formula column  | `⌥ ⇧ A`  | `Option+Shift+A, Alt+Shift+A`                        |
    | Pin or unpin formula columns             | `⌘ ⌥ P`  | `Cmd+Option+P, Ctrl+Option+P, Cmd+Alt+P, Ctrl+Alt+P` |

    ### Blocks & pages

    | Action                      | Shortcut | Registered hotkeys          |
    | --------------------------- | -------- | --------------------------- |
    | Merge the selected scenario | `⌘ ⇧ M`  | `Cmd+Shift+M, Ctrl+Shift+M` |

    ### General

    | Action                                                       | Shortcut | Registered hotkeys          |
    | ------------------------------------------------------------ | -------- | --------------------------- |
    | Close the active overlay or clear the current keyboard state | `Esc`    | `Esc`                       |
    | Open Object Inspector                                        | `⌘ ⇧ T`  | `Cmd+Shift+T, Ctrl+Shift+T` |
    | Reload from the refresh notice                               | `⌘ R`    | `Cmd+R, Ctrl+R`             |
    | Open the developer menu for Runway employees                 | `⌘ ⇧ 0`  | `Cmd+Shift+0, Ctrl+Shift+0` |
  </Tab>

  <Tab title="Windows">
    ### Navigation

    | Action                                                      | Shortcut   | Registered hotkeys                  |
    | ----------------------------------------------------------- | ---------- | ----------------------------------- |
    | Open search                                                 | `Ctrl+K`   | `Cmd+K, Ctrl+K`                     |
    | Open the selected item's detail view                        | `Ctrl+⇧+⏎` | `Cmd+Shift+Enter, Ctrl+Shift+Enter` |
    | Move to the previous item in the detail pane                | `Ctrl+⇧+K` | `Ctrl+Shift+K`                      |
    | Move to the next item in the detail pane                    | `Ctrl+⇧+J` | `Ctrl+Shift+J`                      |
    | Move to the next cell                                       | `Tab`      | `Tab`                               |
    | Move to the previous cell                                   | `⇧+Tab`    | `Shift+Tab`                         |
    | Reveal the current page in the sidebar (in grids and pages) | `Ctrl+⇧+S` | `Cmd+Shift+S, Ctrl+Shift+S`         |
    | Move up                                                     | `↑`        | `Up`                                |
    | Move down                                                   | `↓`        | `Down`                              |
    | Move to the top edge of the current region                  | `Ctrl+↑`   | `Cmd+Up, Ctrl+Up`                   |
    | Move to the bottom edge of the current region               | `Ctrl+↓`   | `Cmd+Down, Ctrl+Down`               |
    | Extend selection up                                         | `⇧+↑`      | `Shift+Up`                          |
    | Extend selection down                                       | `⇧+↓`      | `Shift+Down`                        |
    | Extend selection to the top edge of the current region      | `Ctrl+⇧+↑` | `Cmd+Shift+Up, Ctrl+Shift+Up`       |
    | Extend selection to the bottom edge of the current region   | `Ctrl+⇧+↓` | `Cmd+Shift+Down, Ctrl+Shift+Down`   |
    | Move left                                                   | `←`        | `Left`                              |
    | Move right                                                  | `→`        | `Right`                             |
    | Move to the left edge of the current region                 | `Ctrl+←`   | `Cmd+Left, Ctrl+Left`               |
    | Move to the right edge of the current region                | `Ctrl+→`   | `Cmd+Right, Ctrl+Right`             |
    | Extend selection left                                       | `⇧+←`      | `Shift+Left`                        |
    | Extend selection right                                      | `⇧+→`      | `Shift+Right`                       |
    | Extend selection to the left edge of the current region     | `Ctrl+⇧+←` | `Cmd+Shift+Left, Ctrl+Shift+Left`   |
    | Extend selection to the right edge of the current region    | `Ctrl+⇧+→` | `Cmd+Shift+Right, Ctrl+Shift+Right` |
    | Collapse or expand the sidebar                              | `Ctrl+/`   | `Cmd+/, Ctrl+/`                     |

    ### Editing & formatting

    | Action                                                             | Shortcut   | Registered hotkeys              |
    | ------------------------------------------------------------------ | ---------- | ------------------------------- |
    | Delete selected content or remove the selected driver from a block | `⌫`        | `Backspace, Delete`             |
    | Delete the selected driver or item                                 | `⇧+⌫`      | `Shift+Backspace, Shift+Delete` |
    | Bold selected text                                                 | `Ctrl+B`   | `Cmd+B, Ctrl+B`                 |
    | Underline selected text                                            | `Ctrl+U`   | `Cmd+U, Ctrl+U`                 |
    | Italicize selected text                                            | `Ctrl+I`   | `Cmd+I, Ctrl+I`                 |
    | Strike selected text (in text)                                     | `Ctrl+⇧+S` | `Cmd+Shift+S, Ctrl+Shift+S`     |
    | Undo the latest change                                             | `Ctrl+Z`   | `Cmd+Z, Ctrl+Z`                 |
    | Redo the latest change                                             | `Ctrl+⇧+Z` | `Cmd+Shift+Z, Ctrl+Shift+Z`     |
    | Redo the latest change on Windows                                  | `Ctrl+Y`   | `Ctrl+Y`                        |
    | Increase decimal precision                                         | `Ctrl+.`   | `Cmd+., Ctrl+.`                 |
    | Decrease decimal precision                                         | `Ctrl+⇧+.` | `Cmd+Shift+., Ctrl+Shift+.`     |
    | Select all                                                         | `Ctrl+A`   | `Cmd+A, Ctrl+A`                 |

    ### Drivers & grids

    | Action                                               | Shortcut     | Registered hotkeys                                                   |
    | ---------------------------------------------------- | ------------ | -------------------------------------------------------------------- |
    | Indent the selected driver                           | `Ctrl+Alt+]` | `Cmd+Option+], Ctrl+Option+], Cmd+Alt+], Ctrl+Alt+]`                 |
    | Outdent the selected driver                          | `Ctrl+Alt+[` | `Cmd+Option+[, Ctrl+Option+[, Cmd+Alt+[, Ctrl+Alt+[`                 |
    | Edit the selected cell, or save the active cell edit | `⏎`          | `Enter`                                                              |
    | Open the plan picker in grids                        | `⇧+⏎`        | `Shift+Enter`                                                        |
    | Toggle drill-in in driver grids                      | `Ctrl+⏎`     | `Cmd+Enter, Ctrl+Enter`                                              |
    | Collapse the parent drill-in in driver grids         | `Ctrl+Alt+⏎` | `Cmd+Option+Enter, Ctrl+Option+Enter, Cmd+Alt+Enter, Ctrl+Alt+Enter` |
    | Duplicate the selected driver                        | `Ctrl+D`     | `Cmd+D, Ctrl+D`                                                      |
    | Hide the selected drivers or rows                    | `Ctrl+⇧+H`   | `Cmd+Shift+H, Ctrl+Shift+H`                                          |
    | Group selected drivers                               | `Ctrl+G`     | `Cmd+G, Ctrl+G`                                                      |
    | Hide or show driver names                            | `Alt+N`      | `Option+N, Alt+N`                                                    |
    | Hide or show segment attributes                      | `Alt+S`      | `Option+S, Alt+S`                                                    |
    | Toggle driver formatting                             | `Alt+F`      | `Option+F, Alt+F`                                                    |
    | Add selected drill-in drivers to the block           | `Ctrl+⇧+B`   | `Cmd+Shift+B, Ctrl+Shift+B`                                          |
    | Insert a driver above the current selection          | `Ctrl+Alt+=` | `Cmd+Option+=, Ctrl+Option+=, Cmd+Alt+=, Ctrl+Alt+=`                 |
    | Insert a driver below the current selection          | `Ctrl+Alt+-` | `Cmd+Option+-, Ctrl+Option+-, Cmd+Alt+-, Ctrl+Alt+-`                 |

    ### Formulas

    | Action                                   | Shortcut     | Registered hotkeys                                   |
    | ---------------------------------------- | ------------ | ---------------------------------------------------- |
    | Hide or show the Forecast Formula column | `Alt+⇧+F`    | `Option+Shift+F, Alt+Shift+F`                        |
    | Hide or show the Actuals Formula column  | `Alt+⇧+A`    | `Option+Shift+A, Alt+Shift+A`                        |
    | Pin or unpin formula columns             | `Ctrl+Alt+P` | `Cmd+Option+P, Ctrl+Option+P, Cmd+Alt+P, Ctrl+Alt+P` |

    ### Blocks & pages

    | Action                      | Shortcut   | Registered hotkeys          |
    | --------------------------- | ---------- | --------------------------- |
    | Merge the selected scenario | `Ctrl+⇧+M` | `Cmd+Shift+M, Ctrl+Shift+M` |

    ### General

    | Action                                                       | Shortcut   | Registered hotkeys          |
    | ------------------------------------------------------------ | ---------- | --------------------------- |
    | Close the active overlay or clear the current keyboard state | `Esc`      | `Esc`                       |
    | Open Object Inspector                                        | `Ctrl+⇧+T` | `Cmd+Shift+T, Ctrl+Shift+T` |
    | Reload from the refresh notice                               | `Ctrl+R`   | `Cmd+R, Ctrl+R`             |
    | Open the developer menu for Runway employees                 | `Ctrl+⇧+0` | `Cmd+Shift+0, Ctrl+Shift+0` |
  </Tab>
</Tabs>


# Quickstart: build your first model
Source: https://runway-docs.cfo.ai/get-started/quickstart

Build a simple model in Runway and learn the core workflow from setup to sharing.

In this quickstart, you will import a small financial CSV, shape it into a database, create a modeled driver, build a page with a chart and driver table, and share that page with a teammate.

## What you'll build

By the end, you will have a Runway page that shows monthly financial data by department, a summary driver calculated from that data, a chart block, and a driver table block. The workflow uses [this sample CSV](/sample-data/runway-quickstart-financials.csv), so you can complete it before connecting your real systems.

<Steps>
  <Step title="Get data in">
    Download [the sample financials CSV](/sample-data/runway-quickstart-financials.csv).

    In Runway, connect the **CSV / Raw File Upload** source from the integrations directory. On the data source page, use **Upload a CSV file** to upload the sample file. The upload area notes: **Max size: 50MB. After uploading, click "Run query" to import/refresh the data.**

    Click **Run query** to import the CSV.
  </Step>

  <Step title="Shape it into a database">
    In the query settings, choose **Create database directly from query**.

    Use the CSV columns this way:

    * `Date` is the month for each row.
    * `Account` classifies the financial line item.
    * `Department` is the dimension you will segment by.
    * `Amount` is the number you will model.

    Create the database, then scan the rows to confirm that each account and department appears across the monthly date range.
  </Step>

  <Step title="Create the page and driver">
    Create a page for the quickstart model. Click the **+** next to a section, model, database, or page, then type a page name.

    On the page, type **/** and select [**Driver table**](/concepts/pages/drivers-table-block#creating-a-driver-table-block). Use **+ Add driver** to create a number driver called **Total expenses** directly in the block. If you need to insert it next to an existing row, right-click the driver name or open its left-side menu, then select **+ Insert new driver above** or **+ Insert new driver below**.

    Show **Forecast Formula**, open the new driver's formula, and search for the database name or the `Amount` column name. In the search results, select the database column reference in the `database_name.column_name` format. Runway wraps the reference in `sum()`. Click the database name in the formula pill and apply filters so `Account` includes Cost of Goods Sold, Payroll, Software, Travel, and Facilities.

    Open the driver menu, hover over **Dimensions**, then select [**Expand by dimension**](/concepts/dimensions/segmenting-drivers#segmenting-drivers-in-a-model-using-expand-by-dimension). Select `Department` as the dimension so Runway creates one driver segmented by each department value.
  </Step>

  <Step title="Add a chart">
    Above the driver table, type **/** and select [**Driver charts**](/concepts/pages/charts-block#creating-a-chart-block).

    Choose the existing **Total expenses** driver. New driver charts default to line charts; use **Customize chart** if you want to change the chart type to **Column** or keep **Line**.

    Keep the driver table on the page so the chart shows the trend and the table shows the underlying department segments.
  </Step>

  <Step title="Share it">
    Click **Share** on the page.

    On the **People** tab, use the invite field with placeholder **Email, name or group, separated by commas**, choose an access level, and click **Add**. Leave **Notify via email** on if you want Runway to send the invite.

    Or open the **Links** tab and use **Copy share link**. If the page should stay private, keep **Require login to access** enabled. If you create a guest link, decide whether to enable **Require password**.
  </Step>
</Steps>

## Where to go next

* [How Runway fits together](/get-started/how-runway-fits-together)
* [Connect your real systems](/integrations/intro-to-integrations)
* [Scenarios](/concepts/scenarios)


# Building a P&L
Source: https://runway-docs.cfo.ai/guides/modeling/building-p-and-l

A P&L model serves as the basis for your financial reporting and forecasting needs. This guide explains how to build a customizable P&L from your General Ledger data.

In Runway, the basis of your P\&L will be **multi-level rollups** of your financial data—from granular entries (e.g., vendor, GL account, class) to high-level categories like **Revenue**, **COGS**, or **Operating Expenses**. This makes it easy to analyze performance by category and drill into details when needed.

The following steps will explain how to use Runway **databases** to turn your General Ledger data into a hierarchy — aggregating your data from most granular level to the parent categories you need to report and letting you slice it by department, class or other dimension as needed

The layers are entirely customizable, but often the hierarchy looks like the following:

1. **Root:** Vendor + GL Account Name + Class
2. **Mid-level:** GL Account Name + Class
3. **GL-Level:** GL Account Name
4. **Reporting Category:** New rollup category
5. **Summary:** Parent Category

While the example shown is for demo purposes, you can adapt the same concepts — rolling up **databases** and using **lookups** — to generate a P\&L output for your business needs.

We’ll walk through how to:

* Set up your root database with your most detailed GL data
* Use a lookup to map GL Accounts to your reporting categories
* Aggregate data in a hierarchy that suits your business
* Create a Page you can use for reporting and sharing
* Drill-in from the top of your hierarchy to the most detailed data feeding your model

<Info>
  Note: Runway supports many GL integrations including QuickBooks, Xero, NetSuite, Campfire, Rillet and more. If you haven’t connected your General Ledger data, follow the guides for Accounting integrations [here](/integrations/intro-to-integrations).
</Info>

## Step 1: Bring your GL data into a source Income Statement database

1. Create a new **database** by clicking `+` next to any item in the sidebar
2. Name the database `Level 1: Income Statement by Vendor`
3. Click `edit` in the **database configuration menu** and choose the following inputs:
   * **Data Source:** Choose the integration source query `IS Data`
   * **Driver:** Income Statement Amount
     * Set Using `transaction date` for dates
   * **Segments** (which will define each row of data)
     * `Vendor`
     * `Class`
     * `GL Account Name`
   * Add **Other columns** that will serve as metadata for your segments and be used to group, filter and categorize your GL data

     * `Parent Account`
     * `Account Type`

     <img alt="Level 1 income statement database configuration" />
4. Click **Confirm** to load the database

   <img alt="Level1dboutput" />

## Step 2: Use a lookup table to map GL Accounts to your reporting categories

If you typically recategorize your General Ledger Accounts into different reporting categories, follow directions to create a [Data source-powered lookup](/guides/modeling/lookups#data-source-powered-lookup-recommended) that pairs `GL Account Names` with a `Reporting Category` dimension.

**Add a lookup column** in the `Level 1: Income Statement by Vendor` database

* Select **Insert Values** of `Reporting Category` from **Lookup Table** using `GL Account Name`
* You will see `Reporting Category` items populate the lookup column.

<Tip>
  You can tell a column is sourced from a **lookup** if you hover on one of the tags and see a tool tip `Value is Autofilled` or if you click into the Dimension name column header and the menu says **Edit Lookup**
</Tip>

## Step 3: Configure databases to set a P\&L hierarchy

You now want to simplify your view from the raw data by removing Vendor as a segment — this reduces the granularity of this database

1. **Create a new database** by clicking `+` next to any item in the sidebar
2. **Name the database** Level 2: Income Statement by GL Account Name and Class

   <Tip>
     It's recommended that the database names you choose help describe the segmentation — the database name indicates the granularity of the data it holds, e.g., Income Statement by GL Account Name and Class
   </Tip>
3. **Click edit** in the database configuration menu and choose the following inputs:
   * **Data Source:** Set the data source to your root database e.g., Level 1: Root Income Statement database
   * **Driver:** Amount
   * **Segments**: Select only `GL Account Name` and `Class`
   * Add **Other columns** for `Parent Account` or `Account Type` again, as well as the `Reporting Category` lookup column

You will repeat the same steps to create linked databases with sequentially less segmentation.

4. **Create a new database** named Level 3: Income Statement by GL.
5. **Click edit** in the database configuration menu and select the following:

* **Data Source:** Set the data source to your Level 2: Income Statement by GL and Class database
* **Driver:** Amount
* **Segments:** Select only `GL Account Name`
* **Add Other columns** for `Parent Account` or `Account Type` and `Reporting Category`

6. Click **Confirm**

   <video />

Repeat the steps to create interconnected databases segmented by `Level 4: Reporting Category` and `Level 5: Account Type`

Your final database will be home to your top-level drivers by Account Type which are the aggregation of all underlying databases. Usually these are Revenue, Other Revenue, COGS, Expense and Other Expense

It's helpful to organize the [sidebar](/concepts/sidebar#sections-for-better-organization) using Sections for Income Statement Data and nest the databases to visually remind yourself of their hierarchy

<img alt="Income statement database hierarchy in the sidebar" />

## **Step 4: Complete your P\&L report on a page**

Creating the hierarchy of databases gave us the drivers you'll need to create an output on a page and start wiring up your P\&L with other drivers like Gross Margin and Total Revenue

1. **Create a Page** from the **sidebar**
2. Add a [drivers table block](/concepts/pages/drivers-table-block) by pressing the / key for options
3. Start typing Income Statement Amount in the search bar to call the drivers from the Income Statement databases you've set up

<img alt="Searching for income statement drivers on a page" />

4. You will see Income Statement Amount at all of the segmentations of your databases. Select **Income Statement Amount Account Type** to pull in the most aggregated drivers at the top of your income statement onto the page

   Now by drilling into your drivers from top-down and by adding new drivers, you will build your P\&L report output
5. Pages have affordances to create new drivers and build formulas, like for Gross Profit

   <video />
6. You can add drivers to the report via drill-in. If you click the caret to the left of any driver, you will see the sequential drill down through the database stack you constructed.

   <img alt="Drillinpandl" />
7. If you select the drivers shown in the drill-in, and right-click, you will see an option to Add to Block. This will add the drivers to your page view
   * The last step is to collapse the Amount COGS driver so only the top level driver and inputs are showing on the report that you share
   * The drill-in view is local to your view, you have to select Add to block to expose the drill-in drivers in a report to share
8. You can apply other formatting options like Hide Driver Name and Format as Text to craft a report that mimics the P\&L you present from Excel.

By using **segments**, **mapping tables**, and **roll-up logic**, you can transform raw ledger data into a clean, structured, and drillable income statement.

For more advanced analysis, use your income statement output to compare **budget vs. actuals**, track trends, or share summaries with stakeholders.


# Budget vs. actuals
Source: https://runway-docs.cfo.ai/guides/modeling/bva

Compare your planned budget with actuals so you can track accuracy, spot trends, and refine future forecasts.

Budget vs. actuals analysis compares a locked budget scenario with actuals from Main. Use it after monthly close to understand where performance differed from plan and which assumptions need attention.

## Step 1: Lock your budget

Your budget lives in a scenario. Lock it before running BvA so later Main updates and team edits do not change the comparison baseline.

<Steps>
  <Step title="Disable updates from Main">
    In scenario settings, set **Pull updates from Main** to **Disabled**. This prevents Main changes and integration sync changes from updating the budget scenario.
  </Step>

  <Step title="Prevent edits when needed">
    If the budget should be read-only, disable editing in scenario settings.

    <Frame>
      <img alt="Scenario settings for a budget scenario" />
    </Frame>
  </Step>
</Steps>

You can also use a [locked scenario](/concepts/scenarios#locked-scenarios) as the budget baseline.

## Step 2: Set up your actuals

Actuals come from Main and are governed by [last close](/concepts/last-close).

<Steps>
  <Step title="Open Main">
    Switch to Main.
  </Step>

  <Step title="Set last close">
    Set **last close** to the end of the period you are analyzing. For example, to compare January through March, set last close to March.

    <Frame>
      <img alt="Last close marker moving through months" />
    </Frame>
  </Step>

  <Step title="Review formulas">
    Confirm that actuals formulas are populating closed months and forecast formulas are taking over after last close.
  </Step>
</Steps>

## Step 3: Compare budget vs. actuals

You can analyze variances in tables or charts.

### Create a BvA table

<Steps>
  <Step title="Open a model or page table">
    Open a model or create a **Driver table** block on a page.
  </Step>

  <Step title="Add drivers">
    Add the drivers you want to include in the BvA.
  </Step>

  <Step title="Choose comparison scenarios">
    Click **Customize**, select **Compare**, and choose the budget scenario.
  </Step>

  <Step title="Review variance">
    In comparison view, **Variance** and **Variance %** are on by default. You can toggle comparison metrics from the same menu.
  </Step>

  <Step title="Choose layout">
    Show scenarios as rows or columns.

    <Frame>
      <img alt="Driver table comparing budget and actuals scenarios" />
    </Frame>
  </Step>
</Steps>

### Customize variance display

Variance colors follow the driver's comparison-color setting. For example, expenses usually use a setting where lower values are better, while income usually uses a setting where higher values are better.

Variance respects the driver's abbreviation setting, so thousands and millions display consistently with the rest of the driver table.

<Frame>
  <img alt="Comparison color setting for a variance driver" />
</Frame>

### Create a BvA chart

<Steps>
  <Step title="Create a chart">
    Create a **Driver charts** block on a page.
  </Step>

  <Step title="Add drivers">
    Add the drivers you want to compare.
  </Step>

  <Step title="Compare scenarios">
    Click **Compare** and select the budget scenario.
  </Step>

  <Step title="Choose chart type">
    Use a line or column chart to show trends.

    <Frame>
      <img alt="Chart comparing scenarios over time" />
    </Frame>
  </Step>
</Steps>

## What's next

* [Scenarios](/concepts/scenarios)
* [Last close](/concepts/last-close)
* [Drivers table block](/concepts/pages/drivers-table-block)


# Cohorts modeling
Source: https://runway-docs.cfo.ai/guides/modeling/cohorts

Cohort modeling helps you track and forecast how groups behave over time—whether it’s seat growth, usage patterns, retention, revenue contribution, or churn.

Unlike standard time-series forecasting, cohort models let you isolate trends across specific dimensions like *start date, customer tier, or region*. This makes it easier to answer questions like:

* How do self-serve customers from Q1 2024 behave by month 6?
* What’s the cumulative revenue impact of our March enterprise cohort?
* Where is growth accelerating or tapering across segments?

Here are a few characteristics that make cohort modeling a bit more specialized:

* **Data source configuration:** Cohorts are typically made up of many individual entities—like deals from a CRM or users from a database. To fully leverage this data in Runway, some setup is required.
* **Granularity:** Instead of tracking individual rows or events, cohort models group data into time-based cohorts and analyze patterns across those cohorts.
* **Relative timing:** Most modeling in Runway is calendar-based (month-by-month). With cohort modeling, assumptions are often made on a *relative* timeline—for example, 3 months after a cohort’s start.

This guide walks through how to build a flexible, forward-looking cohort model using age-based assumptions. While the example shown is for demo purposes, you can adapt the same concepts to fit your own forecasting needs.

We’ll walk through how to:

* Import raw CRM-style data into a **Source data** database
* Structure your cohorts using drivers and dimensions in a **Cohorts** database
* Set up and apply cohort-based assumptions in an **Assumptions** database
* Roll everything up into a **Consolidated cohort overview** to see the full picture

Along the way, you’ll set up a flexible foundation for forecasting cohort behavior—whether you’re modeling usage-based revenue, product adoption, or any outcome that plays out over time. You’ll be able to see trends at a high level, and drill down into the individual cohorts that drive those patterns.

Let’s get started.

## Step 1: Bringing in CRM data into a source data database

If you're importing *already-cohorted* data from external sources like Snowflake or BigQuery, you won’t need to segment by dimensions like “customer name.”

To configure a new source data database:

### Drivers

1. **Select the column** that indicates the month when values for a given deal should **start applying**.
2. **Check the columns** containing numbers or dates you plan to use in your model.

   <Info>
     **We recommend enabling “Most Recent Value”** — this ensures values continue to apply in future months beyond the start month. [Read more about filling sparse data here](/guides/modeling/propagating-sparse-data).
   </Info>

   <img alt="Step1 Drivers" />

### Segment by and Other columns

1. **Segment by** the most detailed dimension you expect to drill into:
   * If that’s **customer name**, make sure to:
     * Add any supporting metadata in the **Other columns** section (e.g. sales owner, contract type).
     * Add the **cohort start date** as an **Other column** — this helps with rollups in the next step.
     * If your cohort start dates vary within a month, you’ll see an option to group timestamps by month (or another timeframe).
   * If you’re working with **pre-grouped cohorts** (e.g. without individual deal visibility or with too many deals to break out), segment by the **cohort start month**:
     * You can group assorted cohort dates by month or other units if needed.
     * If you want to split cohorts further by other dimensions (like product line, region, or contract type), select those as additional **Segment by** options.
2. Use **Other columns** to bring in any extra metadata you want available in the model.
3. Once your configuration looks good, press **Confirm**.

<img alt="Step1 Segment By" />

For more detail on database configuration [see article](/concepts/databases/databases-basics#configuring-a-database).

## Step 2: Configuring formulas on source data

The next step is making sure your cohort data is modeled correctly across time — especially for numbers that extend into future months.

1. **Apply forecast formulas** to match actuals where needed.

   If your cohort data includes values extending into the future (e.g. pipeline data), copy the actuals formula into the forecast for your driver columns.

   This ensures that the **“Most Recent Value”** is carried forward even *beyond* the Last Close.

   <img alt="Step2" />
2. **Use Timeseries view to manage formulas**.

   Switch your database view under **Customize > View as > Timeseries** to easily manage formulas across all drivers and trace how values flow from one driver to the next.

   → [Learn more about Timeseries view](/concepts/databases/databases-basics#show-all-columns-as-timeseries)

## Step 3: Setting up cohorts database

In this step, you'll group your source data by cohort so you can model at the cohort level and track trends over time.

Steps:

1. **Create a new database** This will show one segment per cohort. A name like **Cohort Model** works well.
2. **Configure the source**

   Point the cohort database to the one holding your individual customer or deal-level data.

   <Info>
     If you're importing already-cohorted data directly from a data warehouse (e.g. via Snowflake or BigQuery), select the appropriate integration query as your source instead of referencing another Runway database.
   </Info>
3. **Drivers** - Bring in the **cohort start month** as a driver — this allows for time-based modeling.
   * Include any drivers you want to aggregate and model at the cohort level, such as: `Seats`, `Contract value`, `Revenue`.
4. **Segment by**
   * Select the dimension that defines cohort start (e.g. `Contract Start`).
   * Add any other dimensions you'd like to separate cohorts by (e.g. `Geo`, `Product Line`, `Contract Type`).

Hit **Confirm** and review the segments. If anything looks off, you may need to adjust your Segment By or Driver selections.

Now that each cohort is set up as its own segment, the next step is to add columns that enable cohort-based modeling.

1. Add a driver for **cohort age**

   This driver calculates the number of months since each cohort started. It allows you to apply the right assumptions in the right month based on cohort age.

   <img alt="Step3" />
2. Add drivers for **key cohort metrics**

   If there are parts of your model (like churn rate, expansion revenue, etc.) that aren’t available in the source data:

   * **Add placeholder drivers now** so that each cohort/segment has everything needed for forecasting. You can leave formulas blank for now — you’ll connect them to assumptions in the next step.
   * *Optional:* If you want more granularity or plan to drill into these metrics, you can create them in the **source data** **database** and roll them up via the cohort database configuration. Just keep in mind that approach may be less ideal for high-level forecasting.

Next up: **setting up an assumptions database** — where you’ll define the rules that govern how each cohort behaves over time.

## Step 4: Setting up cohort assumptions database

In this example, we’ll create a database to hold the assumptions that drive your cohort model — specifically, **Seat growth rate** as a function of both **Cohort age** and **Customer tier**.

Here’s how to set it up:

1. **Create a new database and segment it by:**
   * **Cohort Age** (as a dimension)
   * **Tier** (e.g. contract tier, customer segment)
2. **Add rows for each combination**

   For each unique combination of age and tier, add a row. In this example, we’ve added 12 months of assumptions for each tier.
3. **Add a driver column for the growth rate**

   This is where you’ll enter assumption for the expected seat growth for each cohort over time.
4. **Add a numerical version of cohort age**

   To apply these assumptions based on a cohort’s calculated age, add an extra driver column:

   * Name it **Cohort Age - Number** to distinguish it from the dimension.
   * This enables formulas to correctly match the cohort age from your main cohort model.

   <Warning>
     This duplication is a known limitation — Runway plans to improve formula functionality so that dimension values can be referenced directly in the future.
   </Warning>
5. **Optional: Calculate assumptions dynamically**

   While the growth rates in this example are hardcoded and static across months, you can:

   * Change formulas over time.
   * Reference other data sources in your model to make these assumptions dynamic and responsive.

Each of these five steps is labeled in the annotated screenshot below:

<img alt="Step4" />

## Step 5: Applying your assumptions in cohort forecasts

With both your **Cohorts database** and **Assumptions database** set up, you can now connect them to forecast key metrics — like growth in Seats — based on each cohort’s **age** and **tier**.

In your **Cohorts database**, use the cohort’s **age** and the dynamic filtering capability of **This Segment** to fetch and apply the right assumption values for each month.

<img alt="Step5" />

<Info>
  This is just one example. Your cohort model may use different logic and multiple drivers — and that’s totally supported. You can build forecasts that combine various assumptions, metrics, and time-based rules.
</Info>

## Step 6: Aggregating your cohorts into a consolidated overview

The final step is to create a **consolidated overview** — a high-level rollup of all cohorts into the segments that matter most for your business. This view makes it easy to analyze trends at a glance while preserving the ability to drill into specific cohorts and underlying customer data.

Example: Summarizing by tier

1. **Create a new database**
2. Set its **source** to your **Cohort Model** database
3. **Segment by**: `Tier` (or another dimension you care about)
4. Pull in the **drivers** you want to aggregate (e.g. `Seats`)
5. Press **Confirm**

You’ll now see one row per tier — a clear overview of performance by segment. From this view, you can drill into:

* The individual **cohorts** that contribute to each tier
* The underlying **customer-level data** from your source database

The video below shows how to configure the Consolidated Overview and how to drill in from the top-level view down to specific assumptions, cohorts, and customers.

<video />

Cohort modeling is famously nuanced. If you’d like help applying these ideas to your own setup, don’t hesitate to reach out to your CXM — they’re here to help.

Happy modeling!


# Commissions
Source: https://runway-docs.cfo.ai/guides/modeling/commissions

Learn how to connect your Sales Team database to a Deals database sourced from your CRM and build commission logic.

## Step 1: Map CRM deal owners to AEs

To align commissions to individual AEs, you’ll need to connect CRM data to HRIS data.

1. Create a new database called **Account Owner Mapping**. Select your **Sales Team** database as the source and segment by **Name**.
   <img alt="Commissions Data Config" />

This will create a line for each **Name** value in the **Sales Team** database.

2. Add a new dimension column and search for **Deal Owner**. Naming may vary depending on your HRIS integration. You can always check your **Deals** database for the exact dimension name.
   <img alt="Setdealowner" />
3. For each relevant row, select the matching **Deal Owner**. Skip rows for manually added new hires—they won’t exist in your CRM data.
   <img alt="Account Owner Map" />
4. In your **Deals** database, add a **Lookup** for the **Name** column.
   <img alt="Name Column Lookup" />

This auto-matches the records for each line. You can think about this as a human-readable VLOOKUP() from Excel. For tidiness, you can hide one of the columns by right-clicking the column header and selecting **Hide in block.**

<img alt="Commisions Lookup Pairing" />

<Info>
  Note: As new employees are hired, you’ll want to revisit the **Account Owner Mapping** to connect their HRIS record to their CRM record.
</Info>

## Step 2: Add commission rate logic

Create a new number driver column in the **Deals** database called **Commission Rate**.

### **Option 1: Flat rate commission**

To set a flat commission rate %, you can select `Add default formula` from the column header sub-menu and hardcode a percentage.

<img alt="Flatcommission" />

### **Option 2: Variable commission rates**

This example demonstrates how you can set assumptions based on dimension values. In this example, `New Business` deals earn an 8% commission, whereas `Existing Business` deals earn a 3% commission.

* The formula references the dimension column `DEAL_TYPE` which only contains the two items: `New Business` or `Existing Business`.
* The logic of the formula reads: *if DEAL\_TYPE = New Business apply an 8% Commission Rate, otherwise apply 3% Commission Rate.*
  <img alt="New business vs. existing business" />

<Tip>
  Since commissions data is part of compensation, many model owners choose to anonymize commission rates and payouts. To do so, right-click the driver column header and toggle **Anonymize data**. You can read more about anonymizing data [here](/guides/sharing/data-anonymization).
</Tip>

## Step 3: Add payout timing logic

In many organizations, commission payouts are deferred until a contract has been active for a set period.

Create a new date driver in your **Deals** database called **Payout Date**. Use `dateAdd()` to add your delay to the deal’s close date. In this example, we assume a 90-day delay.

<img alt="Delaypayment" />

## Step 4: Calculate commissions paid

In your **Deals** database, add a number driver called **Commissions Paid**. Set its formula to multiply **Commission Rate** by the closed-won deal amount from the same deal row, then use **Payout Date** as the timing so the payout lands in the month calculated in Step 3.

For example, if your closed-won deal amount driver is called **Closed Won Deal Amount**, the formula should calculate:

```
Commission Rate * Closed Won Deal Amount
```

Check the values by clicking the Commissions Paid driver column header and selecting `Show as time series`. This view allows you to check whether the amounts paid land in the correct months.

<img alt="Commisions Paid Time Series" />

## Step 5: Aggregate commissions by AE

The last step is to aggregate commissions paid by AE.

In your **Sales Team** database, add a number driver for **Commissions**. Set the formula to sum the **Commissions Paid** driver in your **Deals** database where `Name` is `This Name`.

<img alt="Formulathissegmentcommissions" />

By showing the driver column Commissions as a time series, you can verify the commissions roll up appropriately.

<img alt="Commissionssalesteam" />


# Forecasting with Closed Actuals
Source: https://runway-docs.cfo.ai/guides/modeling/forecasting-with-closed-actuals

Use closed actuals to drive forecast formulas without blending in partial current-period data.

When building forecasts, it's often important to rely only on the most recent month of closed actuals—without blending in partial or forecasted data.

Let’s walk through how to set that up.

### Step 1: Write the Conditional Forecast Formula

Use `if()` logic to switch between calculating a rolling average and carrying forward the prior value:

`if(lastMonth() = lastClose(), [rolling forecast], [last month's value])`

**Example:**

<img alt="Images" />

This sets the forecast to a 6-month average of actuals if you're in the last closed month, or carries forward the previous month’s forecast otherwise. You can change the time range you're summing over in the date selector dropdown.

<img alt="Images" />

***

### Step 2: Apply the Formula to Forecast Rows

Set this logic as the **default forecast formula** for any rows that should follow this smoothing behavior. It will apply automatically across the selected rows in your plan.

## When to Use This Method

This method is ideal when:

* You're forecasting operational expenses that don’t vary dramatically month to month.
* You want smoother transitions between actuals and forecasted data.
* You're building a default forecast structure for teammates to iterate on.

It balances realism with simplicity, automatically adjusting based on data availability.


# FX rate
Source: https://runway-docs.cfo.ai/guides/modeling/fx-rate

When working with multiple entities or subsidiaries across different regions, you often need to consolidate financial data into a single reporting currency. Runway makes this possible by allowing you to convert values denominated in different currencies into one unified currency.

This guide walks you through how to **import exchange rates** and **apply FX conversion** to your financial data in Runway.

## Step 1: Create a Google Sheet for exchange rates

Start by setting up a Google Sheet that will store your exchange rates.

1. Open Google Sheets by typing `sheet.new` in your browser’s address bar, or go to Google Drive and click **+ New > Google Sheets > Blank spreadsheet**.
2. Rename the sheet to something recognizable (e.g., **FX for Runway**).
3. In cell **A1**, use the `IMPORTRANGE` function to pull in exchange rates from Runway’s [live FX sheet](https://docs.google.com/spreadsheets/d/1gAsVhuVDFbXsztrOShUc8bNEFTEa8h7LIInYUXc1opQ/edit?usp=sharing), powered by [XE.com](http://xe.com/)—the same rates used by QuickBooks and Xero:

   ```
   =IMPORTRANGE("your-source-sheet-link","ExchangeRates!A:AI")
   ```
4. Replace `"your-source-sheet-link"` with the actual link to the FX sheet: [Runway Exchange Rates Sheet](https://docs.google.com/spreadsheets/d/1gAsVhuVDFbXsztrOShUc8bNEFTEa8h7LIInYUXc1opQ/edit?usp=sharing)
5. Make sure the range `A:AI` covers all the exchange rate columns. Periodically check the sheet for new currencies and update the range as needed (e.g., A:AI → A:AK).
6. Once the data is imported, create a **named range**:
   * Highlight all the columns (not just the cells with values).
   * Go to **Data > Named ranges**.
   * Give it a name (e.g., `runway_xe_fx`) and click **Done**.

<img alt="Step1 Sheet" />

## Step 2: Connect the FX sheet to Runway

Connect the FX Sheet to Runway using the **Google Sheets long data integration**. [Follow steps 1–11 from this guide to complete the setup.](/integrations/data-storage/google-sheets#connecting-a-google-sheet-with-long-data)

## Step 3: Run an FX query in Runway

1. Once your FX Google Sheet integration has finished syncing, open the query editor in Runway.
2. Paste in the following SQL query to retrieve the exchange rate data.

   ```sql theme={null}
   WITH MonthlyAverageExchangeRates AS (
       SELECT
           month,
           'USD' AS From_Currency,
           To_Currency,
           USD * Rate AS AVG_AMOUNT
       FROM (
           SELECT
               month,
               AVG(USD) AS USD,
               AVG(CHF) AS CHF,
               AVG(EUR) AS EUR,
               AVG(GBP) AS GBP,
               AVG(AUD) AS AUD,
               AVG(HKD) AS HKD,
               AVG(CNY) AS CNY,
               AVG(CAD) AS CAD,
               AVG(INR) AS INR,
               AVG(JPY) AS JPY,
               AVG(NZD) AS NZD,
               AVG(MXN) AS MXN,
               AVG(SEK) AS SEK,
               AVG(PLN) AS PLN,
               AVG(NOK) AS NOK,
               AVG(CRC) AS CRC,
               AVG(SGD) AS SGD,
               AVG(AED) AS AED,
               AVG(ZAR) AS ZAR,
               AVG(BRL) AS BRL,
               AVG(CLP) AS CLP,
               AVG(DKK) AS DKK,
               AVG(KRW) AS KRW,
               AVG(ILS) AS ILS,
               AVG(TRY) AS TRY,
               AVG(GTQ) AS GTQ,
               AVG(DOP) AS DOP,
               AVG(HNL) AS HNL,
               AVG(PEN) AS PEN,
               AVG(PHP) AS PHP,
               AVG(THB) AS THB,
               AVG(MYR) AS MYR,
               AVG(RSD) AS RSD
           FROM
               google_sheets.runway_xe_fx
           GROUP BY
               month
       ) UNPIVOT (
           Rate FOR To_Currency IN (
               CHF, EUR, GBP, AUD, HKD, CNY, CAD, INR, JPY, NZD, MXN, SEK, PLN, NOK,
               CRC, SGD, AED, ZAR, BRL, CLP, DKK, KRW, ILS, TRY, GTQ, DOP, HNL, PEN,
               PHP, THB, MYR, RSD
           )
       )
   ),
   EndOfMonthExchangeRates AS (
       SELECT
           month,
           'USD' AS From_Currency,
           To_Currency,
           USD * Rate AS EOM_AMOUNT
       FROM (
           SELECT
               month,
               max_by(day, day) day,
               max_by(USD, day) USD,
               max_by(CHF, day) CHF,
               max_by(EUR, day) EUR,
               max_by(GBP, day) GBP,
               max_by(AUD, day) AUD,
               max_by(HKD, day) HKD,
               max_by(CNY, day) CNY,
               max_by(CAD, day) CAD,
               max_by(INR, day) INR,
               max_by(JPY, day) JPY,
               max_by(NZD, day) NZD,
               max_by(MXN, day) MXN,
               max_by(SEK, day) SEK,
               max_by(PLN, day) PLN,
               max_by(NOK, day) NOK,
               max_by(CRC, day) CRC,
               max_by(SGD, day) SGD,
               max_by(AED, day) AED,
               max_by(ZAR, day) ZAR,
               max_by(BRL, day) BRL,
               max_by(CLP, day) CLP,
               max_by(DKK, day) DKK,
               max_by(KRW, day) KRW,
               max_by(ILS, day) ILS,
               max_by(TRY, day) TRY,
               max_by(GTQ, day) GTQ,
               max_by(DOP, day) DOP,
               max_by(HNL, day) HNL,
               max_by(PEN, day) PEN,
               max_by(PHP, day) PHP,
               max_by(THB, day) THB,
               max_by(MYR, day) MYR,
               max_by(RSD, day) RSD
           FROM
               google_sheets.runway_xe_fx
           GROUP BY
               month
       ) UNPIVOT (
           Rate FOR To_Currency IN (
               CHF, EUR, GBP, AUD, HKD, CNY, CAD, INR, JPY, NZD, MXN, SEK, PLN, NOK,
               CRC, SGD, AED, ZAR, BRL, CLP, DKK, KRW, ILS, TRY, GTQ, DOP, HNL, PEN,
               PHP, THB, MYR, RSD
           )
       )
   )
   SELECT
       avg_rates.month,
       concat_ws(' - ', avg_rates.from_currency, avg_rates.to_currency) AS exchange,
       avg_rates.from_currency,
       avg_rates.to_currency,
       avg_rates.AVG_AMOUNT,
       eom_rates.EOM_AMOUNT
   FROM
       MonthlyAverageExchangeRates AS avg_rates
   JOIN
       EndOfMonthExchangeRates AS eom_rates
   ON
       avg_rates.month = eom_rates.month
       AND avg_rates.from_currency = eom_rates.from_currency
       AND avg_rates.to_currency = eom_rates.to_currency
   UNION ALL
   SELECT DISTINCT
       avg_rates.month,
       'USD - USD' AS exchange,
       'USD' AS from_currency,
       'USD' AS to_currency,
       1.0 AS AVG_AMOUNT,
       1.0 AS EOM_AMOUNT
   FROM MonthlyAverageExchangeRates avg_rates;
   ```
3. Click **Run Query** to preview and validate the results.
4. Once successful, click **Configure New Database** to create a database from this query.
5. In the setup flow:
   * Rename the database (e.g., **FX Rates**).
   * Set the data source to the FX query you just created.
   * Under **Drivers**, choose between:
     * `AVG_AMOUNT` for average monthly rates.
     * `EOM_AMOUNT` for end-of-month rates.
   * Under **Segment by**, select both:
     * `FROM_CURRENCY` — the base currency (note: this will always be **USD** from the XE feed).
     * `TO_CURRENCY` — the currency you are converting **into.**
6. Click **Confirm** to finish setting up the database.

<img alt="Step3 Query" />

## Step 4: Apply FX translation to your entity’s financial data

Now that you’ve imported exchange rates, you can use them to convert foreign-currency financial data into a unified currency (e.g., USD).

1. Navigate to the database for a subsidiary operating in a foreign currency (e.g., GBP).
2. Click **+ Create New Property** and select **Number Driver**.
3. Give the new driver a clear name (e.g., **Amount in USD**) to distinguish it from the original amount driver.
4. Click the new column’s header and select **Add default formula**.
5. In the **Default Forecast**, enter your conversion formula:

   * ***Amount \[This Segment]*** — the original amount coming from the integration.
   * **EOM\_AMOUNT \[GBP]\[USD]** — the end-of-month exchange rate from the FX table.
   * **AVG\_AMOUNT \[GBP]\[USD]** — the average exchange rate for the month.
   * Use **division** when converting from a foreign currency to USD, i.e., Amount \[*This Segment*] / EOM\_AMOUNT \[GBP]\[USD]
   * Use **multiplication** when converting from USD to another currency, i.e., Amount \[*This Segment*] \* EOM\_AMOUNT \[GBP]\[USD]

   <img alt="Step4 Formula" />


# Headcount planning
Source: https://runway-docs.cfo.ai/guides/modeling/headcount-planning

Build a headcount plan in Runway using HRIS data, segmented databases, and drivers for employee counts and costs.

Headcount planning helps you model current employees, future hires, department-level headcount, and related payroll costs. Use the new HRIS database approach for new implementations; use the legacy expand-by-dimension approach only for older models already built that way.

<Info>
  **Which approach should I use?**

  * **New HRIS databases:** Use regular databases with segmentation. This is recommended for new implementations.
  * **Legacy HRIS databases:** Use **Expand by dimension** in a model. This remains supported for existing models built with the legacy pattern.
</Info>

## Step 1: Set up your employee database

The first step is getting employee data into Runway. The recommended path is to connect an [HRIS integration](/integrations/hris/rippling).

<Frame>
  <img alt="Employee database populated from an HRIS source" />
</Frame>

If you do not have a supported integration available, use one of these alternatives:

* **Google Sheets:** Export employee data to a sheet and connect it to Runway. Keep the sheet current because Runway reflects the connected sheet data.
* **Manual setup:** Create a standalone database directly in Runway with no external data source.

Once your database exists, populate key fields such as **Start date**, **Termination date**, and dimensions for breakdowns such as **Department**, **Role**, or **Location**.

## Step 2: Create headcount drivers

Choose the approach that matches your HRIS database type.

<Tabs>
  <Tab title="New HRIS databases">
    ### Database with segmentation

    New HRIS databases behave like regular databases in Runway, so you can reference them in formulas and stack them to create drill-ins. When segmenting by dimensions that change over time, such as Department or Job Title, segment from the source query so historical changes are captured.

    <Steps>
      <Step title="Create a rollup database">
        Add a database that points to your Employees query or employee source database.
      </Step>

      <Step title="Segment by the dimension">
        In database configuration, segment by the dimension you want to aggregate to, such as Department. This pulls dimension values from the query so new departments and changes can flow in.
      </Step>

      <Step title="Add Headcount">
        Add a numeric driver column called **Headcount**.
      </Step>

      <Step title="Write the count formula">
        Set the formula to count employees where the employee's Department equals this database row's Department, the Start date is on or before this month, and the Termination date is on or after this month.
      </Step>

      <Step title="Add more metrics">
        Add columns such as monthly salary cost or average salary using the same pattern: reference the Employees database and filter to the current row's segment.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Legacy HRIS databases">
    ### Expand by dimension

    If you are working with a legacy HRIS database, use **Expand by dimension** to create one headcount driver per dimension value.

    <Steps>
      <Step title="Create a headcount driver">
        In a model, select **+ Add Driver** and create a driver called **Headcount**.

        <Frame>
          <img alt="New Headcount driver in a model" />
        </Frame>
      </Step>

      <Step title="Expand by the dimension">
        Right-click the new driver, open **Dimensions**, choose **Expand by dimension**, then select the dimension you want to segment by.

        <Frame>
          <img alt="Expand Headcount by Department dimension" />
        </Frame>
      </Step>

      <Step title="Build the formula">
        Double-click the forecast formula cell for one dimensional driver and use `count()` to count employees.

        <Frame>
          <img alt="Count formula for a headcount driver" />
        </Frame>
      </Step>

      <Step title="Filter the employee database">
        Filter the Employees database to the matching dimension value, then add date filters for active employment: Start date on or before this month and Termination date on or after this month.

        <Frame>
          <img alt="Headcount formula filters for department and employment dates" />
        </Frame>
      </Step>

      <Step title="Copy the formula">
        Copy the formula to the rest of the headcount drivers. Because the drivers and formulas reference the same dimension, the filters match each segment.
      </Step>

      <Step title="Create Total Headcount">
        Create a **Total Headcount** driver and sum the segmented headcount drivers, the driver group, or the database directly.
      </Step>
    </Steps>

    <Info>
      If you have multiple dimensions with the same name, select the one coming from your HRIS data source.
    </Info>

    <Warning>
      **Expand by dimension** does not automatically create drivers when new attributes are added to a dimension. If you frequently add departments or other dimension values, update the model manually.
    </Warning>

    <Frame>
      <img alt="Total headcount formula summing segmented headcount drivers" />
    </Frame>

    <Frame>
      <img alt="Total headcount formula summing a driver group" />
    </Frame>

    <Frame>
      <img alt="Total headcount formula summing the employee database directly" />
    </Frame>
  </Tab>
</Tabs>

## Step 3: Add new employees

The easiest place to add new hires is the Employees database.

<Steps>
  <Step title="Add the employee row">
    Click **+ Add Item** in the Employees database.

    <Frame>
      <img alt="New employee row added to the Employees database" />
    </Frame>
  </Step>

  <Step title="Fill required fields">
    Fill in the dimensions and dates used in your formulas, typically Department, Start date, and Termination date if relevant.
  </Step>

  <Step title="Verify the rollup">
    For new HRIS databases, check the rollup database for the correct department segment. For legacy HRIS databases, open the model, click the caret next to the headcount driver, and confirm the employee appears in the breakdown.

    <Frame>
      <img alt="Headcount driver drill-in showing employee inputs" />
    </Frame>
  </Step>
</Steps>

## What's next

* [Prorated salaries](/guides/modeling/prorated-salaries)
* [FX rate](/guides/modeling/fx-rate)
* [Commissions](/guides/modeling/commissions)


# Lookups
Source: https://runway-docs.cfo.ai/guides/modeling/lookups

Lookups—also known as mapping tables—work similarly to Excel’s VLOOKUP, allowing you to assign or insert a dimension in one database based on how it corresponds to a dimension in another.

In Runway, there are two ways to build a mapping table:

* **Data-source powered lookup (Recommended)** – Best suited when the dimensions you’re referencing already come in via a data integration. This ensures new dimensions automatically flow through to your lookup.
* **Fully user-created lookup** – Useful only when the referenced dimension doesn’t exist in your data sources and must be manually created in Runway.

## Data source-powered lookup (Recommended)

1. Create a new database where the lookups will be set.

   <img alt="Lookup Create Db" />
2. Open the **database configuration menu** and choose the appropriate **Data source** and **Segment** to drive your mapping. This is usually the most granular database that holds the values you want to map. In this example, we’re mapping GL Accounts to a Parent Category and will use the most granular database (driven by the accounting system) that contains all GL Accounts.

   <img alt="Lookup Db Config" />
3. After confirming your selection, the chosen **segment** (e.g. GL Account) will populate as a column in the database. Click the **+** icon in the database header, select **Dimension**, and choose an existing dimension or create a new one. This is your **lookup value** — what you'll use in other databases based on the segment that you set in Step 2.

   <img alt="Lookup Create Dimension" />
4. Once the new column appears, **double-click into any cell** to assign the attribute you want the segment to map to. Repeat this for each row—**you must assign an attribute for every row.**

   <img alt="Lookup Fill Cell 1" />
5. As your business grows and changes, this lookup table is where your mapping will be maintained. For example, if new GL Accounts are added, they will automatically flow into this lookup table due to the database configuration. **You must manually set any new mappings for new line items.**

## Fully user-created Lookup

1. Create a new database where the lookups will be set.
2. Click on the + in the database header, select Dimension, and select an existing dimension or create a new one. **This is the value that will be used to look up the additional dimensions that you set.**
   <img alt="Lookup search dimension" />
3. Click on the + in the database header, select dimension again, and select an existing dimension or create another new one. **This is the lookup value that will populate in other databases** based on the dimension that you set in Step 2.
   <img alt="Lookup Create Dimension" />
4. Click Add item in order to create a new row in the database. Because these dimensions are not driven by a data source, **all attributes will need to be manually added**, either by typing them in, copy/pasting into the database, or selecting from the options available.
   <img alt="Lookup Fill Cell" />
5. Select the lookup result dimension in the new row and enter the value that should be inserted when the Step 2 dimension matches. Repeat this for each lookup pair you need.

## Populating lookups in other databases

Once your lookup table is set, you can leverage it in any dimensional database in Runway. Notably, this excludes legacy databases that utilize fields (dimensions or drivers with only column-level formulas), which are exclusively scoped to [HRIS databases](/concepts/databases/hris-databases).

In order to populate a lookup, navigate to a database that includes the dimension you will be using to designate the lookup value (GL Account in the examples above). Click on the + in the database header in order to create a new column and select Lookup.

<img alt="Add Lookup" />

Once selected, you’ll see all possible dimensional lookup combinations (from all databases) and you’ll select the one that matches the mapping you’re expecting. The best way to read these options is to note the headers in this menu. The highlighted selection below is saying that we want to **insert the values of** the Parent Category dimension **from** the Inc Statement Mapping database **using the lookup** GL Account dimension.

<img alt="Lookup Setup" />

Once selected, all values that have been properly mapped in the lookup table will populate. These will automatically flow through as dimensions are updated and maintained in the lookup table itself, as noted in step 5 above.

## Lookups FAQs

<Accordion title="How can I tell if a lookup is empty or has not been set? ">
  The easiest way to do this is to filter on the database where the lookup column has been added and filter for if that lookup value is empty. Any line items with an unpopulated cell in this lookup column is an indication that it has not been set in your lookup table.

  <img alt="Empty Lookup Filter" />
</Accordion>

<Accordion title="Can I do lookups with driver values? ">
  Not at this time but we intend to make this available in the future.
</Accordion>

<Accordion title="Can I set a lookup based on multiple dimensions? ">
  For example, if Dimension A *and* Dimension B, then map Dimension C. We do not have a productized way to do this from a single database, however, there are some creative workarounds for this, pending your use case. Please reach out to your CX Manager to explore this more!
</Accordion>


# Propagating sparse data
Source: https://runway-docs.cfo.ai/guides/modeling/propagating-sparse-data

Not all systems store data as time series. But in Runway, your model lives over time. So when source data is sparse—reported only once or sporadically—Runway gives you a way to pull it forward.

## Why would I need to pull forward sparse data?

Many tools outside of finance don’t track data monthly, and often omit months where nothing changed. For example:

* A CRM deal might only have a single timestamp for when it was created or closed.
* A user might have a signup date, but no updates after that.
* A contract might show up only in the month it was signed.

But in your model, you likely care about these things **across many months**, not just the one they happened in:

* Just because a deal was created in January doesn’t mean its ACV is \$0 in March.
* A user who signed up in April probably still counts as a user in June.
* A contract with \$12k ACV doesn’t just count for one month—it gets recognized over the year.

This is especially important when you want to:

* Spread a value over time (e.g. revenue recognition from contract value).
* Apply **cohort logic**, growth or decay curves based on a starting point.

<img alt="Explaining Sparse" />

## How does it work?

### Integrations data

When configuring an integration-powered database, you’ll see a button for **Most recent value** on the right-hand side. Turn this on if you want the value to **persist** across future months where the source data might be missing.

* Use the **data preview** to check how your source reports values.
* Once you enable this setting, Runway will **automatically apply the most recent value time range** to any drivers based on this data.
* You can also manually adjust the **time range** on formula pills after your database is live.

<Info>
  This only applies when the value is coming back as null. If the value is explicitly 0, that 0 will remain.
</Info>

<img alt="Propagation In Config" />

### General formulas

Even outside of integrations, the **Most recent value** option is also available when writing formulas.

* In any driver formula, open the filter menu for the time range, and select **Most recent value**.
* This will pull the last known **non-null** value forward into future months.

<img alt="Propagation In Formulas" />

### Example

Here are some more examples so you can see how **Most recent value** interacts with dates, zero values, and null values.

<img alt="Propagation Example" />


# Prorated salaries
Source: https://runway-docs.cfo.ai/guides/modeling/prorated-salaries

Use Runway’s date math functions to model prorated salaries for employees who start or leave mid-month with precision.

This guide walks through adding a prorated salary field to your HRIS-sourced Employee database.

As a reminder, HRIS databases work differently than other Runway databases. For more information, please refer to our [HRIS databases article](/concepts/databases/hris-databases).

## Step 1: Create `Prorated Monthly Salary` field

In your **Employee database**, add a **Number field**.

<img alt="Prorated Salaries Step1 Create Field" />

Name the field **Prorated Monthly Salary**.

## Step 2: Handle mid-month starts

1. Add a formula to **Prorated Salary**. Begin with an `if()` statement that checks if the start date falls within the current month.

<img alt="Prorated Salaries Step2 1" />

2. If true, use the `dateDiff()` function to calculate the difference in days between the start date and the end of that month. You'll also want to add 1 day onto this, to ensure you're including the starting day too.

<img alt="Prorated Salaries Step2 2" />

3. Use `daysInMonth()` to divide by the total days in the month and calculate the prorated percentage.

<img alt="Prorated Salaries Step2 3" />

4. Multiply this prorated fraction by the employee's monthly salary (annual salary divided by 12).

<img alt="Prorated Salaries Step2 4" />

## Step 3: Account for mid-month terminations

Extend your `IF()` formula to account for employees who terminate mid-month by adding a second condition.

1. Add a second `IF()` statement by copying the formula so far, and pasting it at the end.
2. Then, update `This Employee.Start Date` to `This Employee.Termination Date` by clicking on each reference of `This Employee.Start Date` -> hitting *Column* -> and then referencing `This Employee.Termination Date` instead.
3. Next, you'll want to update the dateDiff() function so that the first argument is the *start* of the termination month, and the second argument is just the Termination Date itself.

<img alt="Prorated Salaries Step3" />

## Step 4: Calculate full-month salaries

Finally, handle the default case where the employee worked the full month. Set the final case to the (annual) pay rate / 12 for full-month employees.

<img alt="Prorated Salaries Step4 Final Formula" />

Hit **Enter** to save your formula and review your data. This column formula automatically applies to all employees in your database.

<img alt="Prorated Salaries Step4 Save" />

For additional information about headcount planning, see [this article](/guides/modeling/headcount-planning).


# Quota attainment
Source: https://runway-docs.cfo.ai/guides/modeling/quota-attainment

This guide walks through how to build and apply quota attainment models in Runway.

Because quota attainment directly impacts top-line metrics like ARR, Burn, and Cash, it’s a core component of many forecasts, especially for bookings, ramp planning, and commissions.

Common modeling inputs include:

* Start dates for new hires
* Annual and monthly quotas
* Ramp period logic
* Historical attainment trends or override assumptions

## Step 1: Build sales team database

The first step is separating out your sales team from your other headcount planning. As discussed in our [HRIS databases article](/concepts/databases/hris-databases), headcount databases from integrations will behave differently than our standard dimensional database.

You’ll want to bring your sales team out into a dimensional database, as leveraging dimensions for quota attainment is faster and more flexible.

1. Create a new database and set your column headers to the dimensions that will be applicable for quota attainment. In this example, that’s `Name`, `Title`, `Seniority`, `Market`, and `Start Date`.

   <img alt="Step1 1" />
2. Then, paste in that data from your HRIS-integration powered Employee database.

   <img alt="Step1 2" />
3. Layer in any projected hires by adding new items to the database.

   <img alt="Step1 3" />

<Info>
  You can anonymize any sensitive compensation data by right-clicking the column header and selecting ‘Anonymize Data’. More details [here](/guides/sharing/data-anonymization#how-to-anonymize-data).
</Info>

## Step 2: Add annual quotas per employee

Add an **Annual Quota** driver column directly in your **Sales Team database**.

Here, we assign an annual quota based on seniority. This formula will apply to all rows in this database because it’s the default formula.

<img alt="Step2 1" />

Depending on the complexity of your model, you could layer in additional segmentations of quota assignment here. For example, some businesses assign quotas based on seniority *and* market segmentation. Simply nest IF() statements to achieve your desired level of granularity.

Here, we’re saying if you’re a Senior AE focused on the Enterprise market, you have a \$1m annual quota. If you’re Senior but focused on other markets, you have a \$500k quota. Otherwise, you have a \$200k quota.

<img alt="Step2 2" />

It is also possible to have individualized sales targets by overriding the default formula for particular employees.

<img alt="Step2 3" />

## Step 3: Add ramp assumptions

1. **Add `months_since_start`:**

   Use `dateDiff()` to calculate the difference between their start date and the month evaluated in the model. By wrapping it in an `IF()` statement, we can set a floor of 0, which will populate for projected future hires.

   <img alt="Step3 1" />
2. **Calculate `monthly_quota`:**

   Start by taking Annual Quota divided by 12:

   <img alt="Step3 2" />

   Then, build in a ramping assumption to take into account that a new hire will take time to reach full performance. For this example, we’ll assume there’s a 2-month cliff before AEs start closing deals and it takes 6 months to get fully ramped up:

   <img alt="Step3 3" />

<Info>
  Many users also layer in seasonality assumptions at this point. For more details on seasonality, refer to [this article](/guides/modeling/seasonal-forecasting).
</Info>

## Step 4: Bookings capacity & attainment model

Create a new database with your Sales Team database as the source. Bring in the `monthly_quota` data as a driver. You’ll want to segment this data by the granularity you forecast your revenue. In this example, we want to use `Market` from our Sales Team but we don’t forecast revenue based on `Seniority` like we did in the Sales Team database so we’ll leave that out.

<img alt="Step4 1" />

At this stage, what you have is a 100% attainment booking capacity, with ramp and seasonality baked in for each segment. However, to reflect real-world performance, most bookings capacity models apply an attainment assumption to avoid over-inflating forecasted ARR.

Add this assumption in as a column:

<img alt="Step4 2" />

The final step is calculating your fully ramped, adjusted Bookings Capacity, which reflects realistic attainment for each segment.

<img alt="Step4 3" />

## What’s next?

With your quota model in place, you can now:

* Build detailed [ARR dashboards](/concepts/pages/pages-basics)
* Track team performance with [BvA](/guides/modeling/bva) pages
* Model hiring and quota [scenarios](/concepts/scenarios)


# Ranked Lists
Source: https://runway-docs.cfo.ai/guides/modeling/ranked-lists

Learn how to rank database rows by key metrics and use those rankings in filters, formulas, and reports.

Ranked lists allow you to identify and focus on your most important customers, vendors, or contracts by automatically calculating rankings based on key metrics like ARR, contract value, or spending. This workflow is essential for understanding your top performers and can drive strategic decision-making across sales, procurement, and customer success.

## Overview

This workflow involves adding dynamic ranking calculations to your existing databases, then using filters to display only your top performers. Rankings update automatically as your underlying data changes, ensuring you're always seeing current top performers.

## Step 1: Prepare your database

You'll need an existing database with the metric you want to rank by. Common examples include:

* **Customer database** with ARR or revenue metrics
* **Vendor database** with annual spending amounts
* **Contract database** with contract values
* **Employee database** with salary or quota metrics

<img alt="Images" />

## Step 2: Add a rank calculation column

Create a dynamic ranking system that automatically updates as your data changes.

**Add the rank driver:**

* Navigate to your database
* Add a number driver column by clicking **+** and selecting **number driver**
* Name this driver **Rank** (or **ARR Rank**, **Contract Value Rank**, etc.)
* Click on the driver column name and select **Add Default Formula**

**Configure the ranking formula:**

* Type `COUNT()` to use the count function
* Begin typing your database name to surface the database reference
* Choose the **database column reference** option (not the direct driver reference)
* Click the database pill to open formula editor options
* Click **+ Add Rule** to add the ranking filter

**Set up the ranking logic:**

* Set **\[Metric Column]** `is greater than` **\[Metric Column] This Segment**
* For example: **ARR** `is greater than` **ARR This Segment**
  * This counts how many rows have a higher value than the current row
* Add **+ 1** to the end of the formula to convert to standard ranking format. This makes your top rank #1, rather than #0. **Complete formula example:**

`COUNT([Database Name].[Metric Column]) + 1`

Where the COUNT function has the "greater than This Segment" filter applied.

<img alt="Rank formula configuration for a database" />

## Step 3: Validate your rankings

Verify that your ranking system is working correctly.

**Check the results:**

* Your highest value record should show **Rank = 1**
* Your second highest should show **Rank = 2**
* Rankings should be consecutive (1, 2, 3, 4...) unless there are ties

**Sort your database view:**

* Click the column header of your ranking metric (ARR, Contract Value, etc.)
* Select **Sort Descending** to show highest values first
* Verify that Rank 1 corresponds to your highest value

## Step 4: Using Rank throughout your workspace

### Filter for top performers in database view or database block

Apply filters directly in your database to focus on top performers.

**Filter the database view:**

* In your database, click **+ Add Filter**
* Select your **Rank** driver
* Set the condition to `is less than or equal to` and enter your desired number
  * For top 10 customers: **Rank** `is less than or equal to` **10**
  * For top 5 vendors: **Rank** `is less than or equal to` **5**

**Sort for better visibility:**

* Click the column header of your ranking metric (ARR, Contract Value, etc.)
* Select **Sort Ascending** to show highest rankings first

<img alt="Images" />

### Reference ranked data in models and formulas

Use your top performers data to drive calculations in financial models.

**Sum top performer metrics:**

* In a model, create a driver like **Top 10 Customer ARR**
* Click into the forecast formula and type `sum()`
* Reference your database with appropriate filters:
  * Database reference: **Customer Database.ARR**
  * Add filter: **Customer Database.Rank** `is less than or equal to` **10**

**Track concentration metrics:**

* Create percentage calculations showing what portion of revenue comes from top customers
* Example: **Top 5 Customer %** = `[Top 5 Customer ARR] ÷ [Total ARR]`

Ranked lists help you keep focus on the customers, vendors, contracts, or employees that matter most as your underlying data changes.


# Revenue recognition
Source: https://runway-docs.cfo.ai/guides/modeling/revenue-recognition

Generally accepted accounting principles (GAAP) require that businesses recognize revenue when it’s earned (accrual accounting) rather than when payment is received (cash accounting). This article explains how to build a revenue recognition model in Runway for recurring contracts.

## Step 1: Prepare your integrations and databases

First, connect the data sources you plan to use to model revenue recognition. Runway has [CRM](/integrations/revenue/hubspot), [data warehouse](/integrations/data-storage/data-warehouses#data-warehouses), and [Google Sheet](/integrations/data-storage/google-sheets) integrations available.

You can also manually copy data into a Runway database. You will need to follow [database configuration directions](/concepts/databases/databases-basics#configuring-a-database).

The Runway team can help you write a query that will bring in the fields that you will need for revenue recognition modeling from your integration source.

Typically, for a revenue recognition model the contract or deal databases are segmented by a unique ID and Customer Name, depending on the fields your business uses to track contracts.

The following items brought into Runway as number and date drivers are standard for a revenue recognition model:

* Contract Amount
* Contract Term length
* Contract Start Date
* Contract End Date

Note the example of a simple contract database below:

* Contract ID and Customer Name dimensions are set as Segments
* Contract Start Date, Contract Value and Contract Term (Months) are Drivers
* Payment Cadence is an Other column, meaning it is metadata tied to each Contract ID and Customer Name segment

<img alt="Contract database segmented by contract ID and customer name" />

## Step 2: Set up contract start date, end date and term length

To recognize revenue over the length of a contract, you will need Start Date, Contract Term and Contract End Date drivers.

### Calculate contract end date using start date and term (months)

1. Add a date driver column by clicking the + at the right hand side of the database and selecting date driver

   <img alt="Adding a contract end date driver" />
2. Name the date driver **Contract End Date**
3. Click on the driver column name and select `Add Default Formula`. Default formulas allow you to set a formula for every segment of the driver.
4. Use `DateAdd()` to calculate the Contract End Date based on Contract Start Date and Contract Term Length.

   <img alt="DateAdd formula for contract end date" />

   <Note>
     Note that the units must be wrapped in single-quotes, e.g. months as 'm'
   </Note>

   <video />

### Calculate contract term (months) from contract start date and end date

1. Add a **number driver column** by clicking the `+` at the right hand side of the database and selecting **number driver**.

   <img alt="Adding a contract term driver" />
2. Edit the name for the **number driver column**.
3. Click the driver column name, then select **Add Default Formula** to set a formula for every segment of data (in this example, a formula for Contract Term Length will be propagated to each intersection of Contract ID and Customer Name).
4. Use `DateDiff()` function to calculate a Contract Term Length based on contract start date and Contract End Date.

   <img alt="DateDiff formula for contract term length" />

   <video />

## Step 3: Build logic to recognize revenue over length of contract

Here’s how to create a formula that will spread your revenue over the period that services get delivered.

1. Add a **number driver column** to the database by clicking the `+` to the right of the last database column.

   <img alt="Adding a contract term driver" />

2. Name this driver **Monthly Recognized Revenue**.

3. Click into the driver name and select `Add default formula` to open the default formula editor for the driver column.

4. Begin typing Contract Value to surface the Contract Value driver.

5. You will see two options to reference the Contract Value driver.

   * A **database column reference** with the naming convention `Database Name.Driver Column`.
     * This option gives you the affordance to apply date filters and filters for dimensions you have not set as database Segments. For revenue recognition purposes, you will want to choose the database reference option so you have access to date filters.
   * **Direct Driver reference** option, which appears as Contract Value *This Segment.*
     * This option offers cleaner name format and the ability to filter based on database **segments.**

   <img alt="Contract value database reference in the formula editor" />

6. Click the driver pill to open the formula editor options.

7. Click **+ Add Rule** to add **filters to the formula**. These will make sure the contract value hits your model only between Contract start and End dates.

   * Set **Contract Start Date.Month** `is on or before` **This month**.
   * Set **Contract End Date.Month** `is after` **This month**.
   * Set **Segment** `is` **This Segment** to apply the rules across all slices of `Contract ID` x `Customer Name`. You can review how to **create dynamic formulas** using *This Segment* [here](/concepts/databases/formulas-in-databases#example%3A-dynamic-default-formula-using-this-segment).

   <img alt="Formula filters for recognized revenue timing" />

8. Finally, divide by `Contract Term Length (Months)` to calculate a monthly value. Each driver will be populated from Contract Start to Contract End date.

   <img alt="Recognized revenue values across contract months" />

<Check>
  To check if the formula is calculating correctly, select all months of values and check whether count and sum in the calculation preview match the Contract Term Length and Contract Value

  <img alt="Check Sumavg" />
</Check>

## Step 4: Drive revenue forecast formulas by referencing Contracts data

Finally, you will need to **wire up the Contract database** to **drive Revenue forecasts** upstream in your model. This is the last step required to ensure that your topline is actively driven by the `Monthly Revenue Recognition` driver you've built.

1. Navigate to a `Revenue` driver if it already exists in your Runway instance **or** create a new driver in a [Model](/concepts/models/models-basics) or on a [Page](/concepts/pages/pages-basics)
2. **Click into the forecast formula** of the driver and type `sum()`
   * You can create a `sum()` two ways:
     * Use a **driver reference** that directly references **Monthly Recognized Revenue** `All Customer Names All Contract IDs`.

       <img alt="Monthly recognized revenue driver reference" />

       <img alt="Monthly recognized revenue all-segments reference" />
     * Create a sum over the **database column reference**, which gives you the affordance to **apply filters** based on non-Segment dimensions.

       <img alt="Monthly recognized revenue database column reference" />

       <img alt="Database column reference filters" />
3. **Click the caret** to the left of the Revenue driver to drill into inputs in-line.
   * This lets you quickly check that `Monthly Recognized Revenue` drivers for each `Customer x Contract ID` segment pull into the aggregation as expected.
   * Based on the drill-in, you will be able to see whether `Monthly Recognized Revenue` values begin and end on the correct dates.
   * Each `Monthly Recognized Revenue` driver has a Runway arrow that will open up a [detail pane](/concepts/drivers/driver-details-pane#details-pane) that will let you investigate the driver's formulas, inputs and Plans.

<img alt="Revenue driver drill-in showing monthly recognized revenue inputs" />


# Seasonal forecasting
Source: https://runway-docs.cfo.ai/guides/modeling/seasonal-forecasting

This guide walks through several ways to model seasonality in Runway, depending on where it occurs in your business.

Revenue and expenses often fluctuate throughout the year. Runway makes it easy to handle time-based variability, since all data is a time series.

## Where should I be forecasting seasonality?

Forecast seasonality at the same level where it shows up in your business.

* If it’s **company-wide**, apply seasonality factors to a high-level driver in a model or directly to a default formula in a database column.
* If seasonality varies by **customer, store, or contract**, use **formula overrides** in the relevant database.

We’ll walk through both approaches below. Runway offers flexibility, so you can adapt the method to what makes the most sense for your model.

<Info>
  Need a refresher on formulas? [Start here →](/concepts/formulas/formulas-basics)
</Info>

### Annual seasonality - Driver & default formula

1. Define a new driver to capture your seasonal pattern. If this pattern is global (not tied to a particular customer), add it in a [driver table block in a page](/concepts/pages/drivers-table-block) or a [model](/concepts/models/models-basics).
   * **No historical data?** Hardcode seasonality for a typical year.
     <img alt="Annual 1" />
   * **Have historical data?** Calculate seasonality directly in the driver’s actuals formula.
     In this example, we’re taking 1 month’s value of ARR and dividing it by the sum of the last rolling 12 months of ARR. Doing so will give us the proportion of ARR incurred in a particular month.
     <img alt="Annual 2" />
2. To keep seasonality consistent across future months, reference the same month from the previous year in your forecast formula using the **One Year Ago** date reference.
   <img alt="Annual 3" />
3. Apply this seasonal adjustment to the relevant forecast drivers.
   In this example, we’re multiplying the Account Executive (AE) quota projection by the seasonality driver within a database. This allows you to use a shared formula while giving each AE a tailored goal.
   <img alt="Annual 4" />
   The impact will cascade into downstream metrics like ARR that aggregate the AE quota projection.
   <img alt="Annual 5" />

### Quarterly seasonality - Date math & date drivers

Let’s take it up a notch and add in date functions and drivers. For this walkthrough, we’ll be working with a sales team that closes 80% of their quota during the last month of the quarter.

1. Create a **Quarter End** helper driver. Go to Format and display > Type > Date to change to a date driver. This will output a human-readable date, rather than a number.
   <img alt="Quarterly 1" />
2. Use `thisQuarter()` to return the start of each quarter, then add 2 months to return the *end* of that quarter.
   <Info>
     For more details on date functions in Runway, see [Functions and operators](/concepts/formulas/functions-operators#date-calculation).
   </Info>
   <img alt="Quarterly 2" />
3. Head back to your sales roster database and calculate their monthly quota using the **Quarter End driver** you just made. Wrapping this logic in an `IF()` statement allows us to allocate 80% of a quarter’s quota in the last month and 10% in the other months.
   <img alt="Quarterly 3" />
   <img alt="Quarterly 4" />

### Granular seasonality

For this walkthrough, let’s think about customer usage of a SaaS business. Given each customer’s business, they might use a platform at different intensities throughout the year. A florist will not have the same usage as a ski resort, for example.

In this case, because seasonality occurs at a more granular level, we'll want to forecast it at that same level—on a customer-by-customer basis.

We’ll take all the core concepts we’ve walked through above, but apply them by overriding the default formula in a database column.

1. Within your database, create a column for your seasonality factor.
   Give it a sensible default - depending on your business, this could be a general seasonality factor (like those discussed above) or just a flat forecast.
   <img alt="Granular 1" />
2. Apply the seasonality factor to the affected database columns.
   In this example, we are applying our seasonality factor to the Usage driver.
   <img alt="Granular 2" />
3. For relevant segments, instead of using the default column formula defined in the previous step, you can override it by changing the formula for the row.
   For example, you could offset the overall seasonality factor to match a customer’s usage patterns.
   <img alt="Granular 3" />
   Alternatively, you could hardcode a customer’s typical year’s worth of seasonality and have that recur annually.
   <img alt="Granular 4" />

## Wrap-up

Seasonality doesn’t have to be hardcoded across dozens of drivers. By using Runway’s date references and formula flexibility, you can structure your model to scale seasonality cleanly—whether annually, quarterly, or by segment.

If you need help deciding which method fits your use case, reach out to your CXM or drop us a line in Slack.


# Adding users
Source: https://runway-docs.cfo.ai/guides/sharing/adding-users

Invite people to Runway from the Share sheet and choose the access they should receive.

Use the **Share** sheet when you want to invite people to Runway and give them access to a page, model, database, section, block, or scenario. Invited users default to the Member role; use [Roles and access](/reference/roles-and-access) and [Permissions](/guides/sharing/permissions) to choose the right resource access.

## Invite people from the Share sheet

<Steps>
  <Step title="Open the Share sheet">
    Open the resource you want to share, then click **Share**.
  </Step>

  <Step title="Open People">
    Select the **People** tab.
  </Step>

  <Step title="Enter people or groups">
    Use the field labeled **Email, name or group, separated by commas**. You can enter one person, multiple people, or an existing group.
  </Step>

  <Step title="Choose access">
    Pick the access level for each invitee, then click **Add**.
  </Step>

  <Step title="Choose whether to notify them">
    Leave **Notify via email** on to send an invitation. Add an **Optional message** when the invite needs context.
  </Step>
</Steps>

<Frame>
  <img alt="Share sheet People tab for inviting users" />
</Frame>

## Pending invites

People who have been invited but have not joined yet show a **Pending** badge. After they join, they appear as workspace users and can be managed through sharing settings.

## Org-wide access

The **Everyone at \{org}** row controls default access for everyone in your workspace. Use it when a resource should be broadly visible or editable inside your org, and use individual rows or groups for narrower exceptions.

<Warning>
  Role and resource access are separate. Inviting someone makes them a Member by default, but the resource access you choose still controls what they can do on the shared item.
</Warning>

## When to use links or groups instead

Use [share links](/guides/sharing/share-links) when you want a page-level link for people outside your org. Use [groups](/guides/sharing/groups) when the same set of people should receive access to multiple resources.

## FAQ

<Accordion title="What role do invited users get?">
  Invited users default to the Member role. See [Roles and access](/reference/roles-and-access) for what that role means.
</Accordion>

<Accordion title="Can I invite several people at once?">
  Yes. Enter multiple emails, names, or groups in **Email, name or group, separated by commas**.
</Accordion>

<Accordion title="Can I share with everyone in my org?">
  Yes. Use the **Everyone at \{org}** row to set org-wide access for the resource.
</Accordion>

## What's next

* [Share links & guest access](/guides/sharing/share-links)
* [Groups](/guides/sharing/groups)
* [Permissions](/guides/sharing/permissions)


# Comments
Source: https://runway-docs.cfo.ai/guides/sharing/comments

Use comments to leave context, ask questions, and communicate around your model.

## What you can comment on

You can leave comments on most core surfaces in Runway via the right click menu, or by clicking on the six-dot menu for a block. You can also comment on pages via the ellipsis menu in the side navigation.

<Frame>
  <img alt="Comment option on a Runway cell" />
</Frame>

Existing comments are indicated by a notch in the top-right of the corresponding cell (for comments on specific cells) or a dot to the left of the block (for comments on blocks).

<Frame>
  <img alt="Comment indicator on a Runway cell" />
</Frame>

When writing a comment, you can @-mention a user and it will send them an in-app notification.

You can resolve a comment thread by clicking the checkbox on a thread. This will hide the resolved comment thread from view.

## Comments notifications

The top navigation bar has a tray to surface the comment threads you're involved in.

The first tab, "My threads", highlights threads you're following (tagged or participating in). The second tab, "Other threads in this scenario", shows all comments on the scenario you're currently viewing, including ones you are not yet following.

Click a comment to navigate to comment's target content. This may navigate you to a different scenario.

## Commenting and permissions

Viewing and participating in comment threads follows the access of the driver, page, and scenario where the comment is made. See [Permissions](/guides/sharing/permissions) for the current access model.

Changes to model data in Main move into draft scenarios before they affect Main. Merge access is controlled by permissions.

## Comments and Scenarios

**Reading comments:**

As you navigate the app, you will see comments made on your current scenario. In addition, if you're on a scenario that automatically pulls updates from Main, you'll see comments from Main.

**Writing comments:**

Comments are made to the scenario that is currently active.

Merging a scenario does not resolve comments. You can see comments that are staged for merging in the "Compare and merge" screen.

* If you are on the Main Scenario (not a draft) comments will be made directly onto Main Scenario, immediately visible to others.
* If you're working on a non-Main Scenario, comments are made directly to that scenario, visible to all users with access to that scenario
* If you're working on a draft, comments will be made onto the draft.
  * For others to see your comments on a draft, you'll have to do one of the following
    * @-mention someone in a comment. They'll be notified in the app and be able to navigate to your draft.
    * Share a link to your draft.
    * Or [merge](/concepts/scenarios) your draft into the Main Scenario


# Data anonymization
Source: https://runway-docs.cfo.ai/guides/sharing/data-anonymization

Runway is designed to foster collaboration between finance teams and the broader organization. However, collaboration doesn’t mean exposing sensitive information—like salaries—to everyone.

With Runway, you can anonymize sensitive data and reveal it selectively, ensuring privacy while enabling deep collaboration.

## How to anonymize data

Imagine you have an employees database and want your department heads to collaborate with you on planning new hires, raises, or bonuses. You need each department head to see salary information only for their own team—not for everyone else.

As an Admin, you can easily anonymize specific columns in your database to protect sensitive data:

1. Open your database and click on the header of the column you want to anonymize (e.g., "Salary").
2. In the column settings, enable **Anonymize data**.

<Info>
  Only Admin users can change this setting.
</Info>

<img alt="Enable Data Anonymization" />

Once anonymized:

* All non-Admin users will see the anonymized data displayed as `***`, regardless of where the data appears (e.g., database blocks or driver tables on any Runway page).
* Admin users will continue to see the actual data values, maintaining full visibility.

In the example below, notice how anonymized salary data appears to non-Admin users:

<img alt="Anonymized Data On Page" />

Admins, however, will always see the original data:

<img alt="Regular Data On Page" />

## Revealing anonymized data on a specific page

After anonymizing sensitive data, you might still want certain team members to view some of this data when it’s relevant. Runway lets you selectively reveal anonymized data on specific pages, so team members see only what's necessary without compromising privacy.

**Example:** Let’s say you created a dedicated page for your Head of Sales to collaborate on their team's headcount and hiring plan. You want them to see salary details, but **only** for their own team members.

To selectively reveal anonymized data on a specific page:

1. Add your employee database as a **database block** on the relevant page.
2. Apply a filter to show only the employees relevant to that user (e.g., Sales department).
3. Click **Customize** on the database block.
4. Enable the toggle labeled **Reveal hidden data in this block**.

Once enabled:

* Users viewing this block will see the original, non-redacted data **only within this specific block**.
* Filters and columns become locked for non-Admins of this page. They won’t be able to change filters or show additional columns, ensuring sensitive information remains protected.

<Info>
  Revealing anonymized data is available **only for database blocks** and **not for driver table blocks.**
</Info>

<img alt="Reveal Data" />

## Data anonymization FAQ

<Accordion title="Can I reveal anonymized data in a driver table block instead of a database block?">
  Currently, revealing anonymized data is only supported for database blocks. If you’d find this capability helpful for driver table blocks, let us know in Slack or share your feedback with your CXM so we can prioritize it.
</Accordion>

<Accordion title="Can I anonymize drivers that don’t originate from a database?">
  Not currently. Data anonymization is available only for database columns. If anonymizing other types of drivers would be valuable to you, please reach out in Slack or share your feedback with your CXM to help us prioritize future improvements.
</Accordion>


# Groups
Source: https://runway-docs.cfo.ai/guides/sharing/groups

Organize users into groups so you can manage Runway access more efficiently.

Groups let you assign the same access to several people at once. Use groups for teams, departments, board viewers, or any recurring audience that should receive the same sharing settings across resources.

## Create a group from the Share sheet

<Steps>
  <Step title="Open sharing">
    Open a resource and click **Share**.
  </Step>

  <Step title="Search for a group">
    In the People tab, use **Type to search or create**.
  </Step>

  <Step title="Create the group">
    Type the group name, choose **Create "\{name}" group**, then click **Create group**.
  </Step>

  <Step title="Add members and access">
    Add users to the group, then choose the group's access level for the resource.
  </Step>
</Steps>

## Manage groups

Use **Manage groups** from the Share sheet to review existing groups. From the group list, use **Add users to group** to update membership or **View group** to inspect a group before sharing with it.

## Share to a group

<Steps>
  <Step title="Open the People tab">
    Open **Share**, then select **People**.
  </Step>

  <Step title="Find the group">
    Enter the group name in **Email, name or group, separated by commas**.
  </Step>

  <Step title="Choose access">
    Select the access level, then add the group to the resource.
  </Step>
</Steps>

## Inherited access

Some rows show that access comes from a parent resource with **People in**. That means the current resource follows the default access settings from its parent.

If you change inherited access for a resource, Runway asks you to **Change access for \{resourceName}**. Choose **Change and unlink** when the resource should stop following the parent and keep its own access settings.

Unlinked resources show the banner **Share settings on this \{resourceName} are unlinked from the default access settings.** Use **Relink** and confirm **Relink share settings** to follow the parent again. Use **Reset to default access level** when you want to discard custom access and return to the default access level.

## FAQ

<Accordion title="Does changing a group update every resource shared with that group?">
  Membership changes affect the people who receive group access. Each resource still keeps its own access level for that group.
</Accordion>

<Accordion title="What does unlinking share settings mean?">
  It means the resource no longer follows the parent resource's default access settings. The resource keeps its own sharing rows until you relink or reset it.
</Accordion>

<Accordion title="Can I share with a group and individual users?">
  Yes. A resource can have group rows and individual user rows.
</Accordion>

## What's next

* [Adding users](/guides/sharing/adding-users)
* [Share links & guest access](/guides/sharing/share-links)
* [Permissions](/guides/sharing/permissions)


# Permissions
Source: https://runway-docs.cfo.ai/guides/sharing/permissions

Control who can view, edit, share, merge, export, and drill into Runway resources.

Permissions combine a user's org role with resource-level access. Use roles to set a user's default workspace capabilities, then use the share sheet to control access to specific pages, sections, blocks, scenarios, and database columns.

## User roles

Runway roles are hierarchical: Owner, Admin, Manager, Member, Guest, then Anonymous user. Invited users default to Member unless you choose another role. For the canonical role and access matrix, see [Roles and access](/reference/roles-and-access).

| Role           | Default access pattern                         | Distinctive behavior                                                                                 |
| -------------- | ---------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| Owner          | Full workspace access                          | Owns the workspace and cannot be modified from sharing UIs.                                          |
| Admin          | Full workspace access                          | Can configure the model, workspace settings, and workspace info.                                     |
| Manager        | Broad internal modeling access with exceptions | Can trace and edit models, create scenarios, and access shared workspace information.                |
| Member         | Limited default access                         | Can trace models, create scenarios, and access shared workspace information after access is granted. |
| Guest          | Shared-content access only                     | Can view pages and data shared with them.                                                            |
| Anonymous user | Share-link visitor access only                 | Created through page share links; never selectable as a normal role.                                 |

### Owner

Owners have workspace-level control and are treated as a protected system role in sharing. Use Owner sparingly for the people accountable for the workspace itself.

### Admin

Admins can configure the model, workspace settings, and workspace info. This role is usually for finance or operations team members who administer Runway.

### Manager

Managers are internal collaborators who need broad modeling access without full admin control. They can create scenarios and work with shared model information, with exceptions for sensitive workspace areas.

### Member

Members are internal collaborators who need access to specific shared resources. They can trace models and create scenarios where their access allows it.

### Guest

Guests are external or limited collaborators who should only see content explicitly shared with them.

### Anonymous user

Anonymous users are provisioned through page share links. They are not invited through the role picker and should be managed through link security settings.

## Access levels

Open the **Share** sheet to manage resource access. The sheet has **People** and **Links** tabs.

The **People** tab includes an invite field with placeholder **Email, name or group, separated by commas**, an **Add** button, an access-level dropdown, **Notify via email**, and an optional message field. The org-wide row appears as **Everyone at \{orgName}**.

The standard access levels are:

| Access level    | Meaning                                                                                |
| --------------- | -------------------------------------------------------------------------------------- |
| **Full access** | Can edit the resource and manage its access where the resource supports those actions. |
| **Can edit**    | Can edit the resource but cannot manage sharing or deletion.                           |
| **Can view**    | Can view the resource without editing it.                                              |
| **No access**   | Cannot view or access the resource.                                                    |

Different resource types offer different subsets of access levels:

| Resource type   | Access levels offered                                                    |
| --------------- | ------------------------------------------------------------------------ |
| Page            | Full access, Can edit, Can view, No access                               |
| Section         | Full access, Can view, No access                                         |
| Block           | Full access, Can view, No access, plus drill-in control where applicable |
| Scenario        | Full access, Can view, No access, with merge control where enabled       |
| Database column | Can view, No access                                                      |

For the complete capability rules, use [Roles and access](/reference/roles-and-access) as the canonical matrix.

## Share links

Use the **Links** tab to create and manage page links. Link rows include **Copy share link** and security options:

* **Require login to access**
* **Require password**
* **Guest invite link**

Share links exist only on pages. If login is not required, a **Password** field can be used when password protection is enabled.

## Groups

Groups are created and managed from the share sheet. Search for a group, or type a new name and choose **Create "\{name}" group**. Group rows include actions such as **Add users to group** and **View group**.

## Inherited access

Resources can inherit access from a parent resource. Inherited rows show **People in** a parent resource. If you override inherited access, Runway prompts **Change access for \{resourceName}** and confirms with **Change and unlink**.

When a resource is unlinked from inherited settings, Runway shows a banner that its share settings are unlinked from default access settings. Use **Relink** or **Reset to default access level** to return to inherited access.

## What's next

* [Roles and access](/reference/roles-and-access)
* [Adding users](/guides/sharing/adding-users)
* [Share links](/guides/sharing/share-links)


# Share links & guest access
Source: https://runway-docs.cfo.ai/guides/sharing/share-links

Share Runway pages with guests and control access through share links.

Share links are page-level links for people outside your org. Use them when you need to share a page with a guest, investor, or collaborator without inviting them as a normal workspace user first.

## Create a share link

<Steps>
  <Step title="Open the page">
    Open the page you want to share.
  </Step>

  <Step title="Open sharing">
    Click **Share**.
  </Step>

  <Step title="Open Links">
    Select the **Links** tab.
  </Step>

  <Step title="Copy the link">
    Click **Copy share link** on the link row you want to use.
  </Step>

  <Step title="Choose security options">
    Turn on **Require login to access** or **Require password** when the page needs extra protection. If password access is enabled without login, enter the password in **Password**.
  </Step>
</Steps>

## Guest invite links

Turn on **Guest invite link** when someone with the link should be provisioned as a guest through the link flow. Share links exist only on pages, so use direct invites when you need to grant access to models, databases, sections, blocks, or scenarios.

## Anonymous visitors

If the link allows anonymous access, visitors can open the shared page through the link. Their access is limited to what the page link grants; they do not receive broad workspace access.

## Links vs. invites

Use links for page-level external sharing. Use [invites](/guides/sharing/adding-users) when someone should become a normal workspace user or when you need to share a non-page resource. Use [groups](/guides/sharing/groups) when several existing users need the same access.

## FAQ

<Accordion title="How do I revoke a share link?">
  Open **Share**, go to **Links**, and remove or disable the link access you no longer want to allow.
</Accordion>

<Accordion title="What happens when I change the password?">
  People using the old password must enter the new password the next time the link requires password access.
</Accordion>

<Accordion title="Can share links be used for models or databases?">
  Share links are page-level links. Use direct invites for models, databases, sections, blocks, and scenarios.
</Accordion>

## What's next

* [Adding users](/guides/sharing/adding-users)
* [Groups](/guides/sharing/groups)
* [Permissions](/guides/sharing/permissions)


# SSO & authentication
Source: https://runway-docs.cfo.ai/guides/sharing/sso

Configure authentication and single sign-on settings for your Runway organization.

Runway supports single sign-on for workspaces that need identity-provider controlled login. Use SSO when users with your company email domain should authenticate through your IdP instead of choosing a personal login method.

## Login options

The login page offers **Continue with Google**, **Continue with Rippling**, **Continue with Microsoft**, **Continue with Xero**, and **Sign in with SSO**.

<Steps>
  <Step title="Choose SSO">
    Click **Sign in with SSO** on the login page.
  </Step>

  <Step title="Enter your workspace slug">
    Enter the slug in the form with placeholder **org-url**. The page shows it as `v2.cfo.ai/{slug}`.
  </Step>

  <Step title="Continue through your IdP">
    Complete the login flow in your identity provider.
  </Step>
</Steps>

## Enable SSO

SSO is configured by Runway. Contact support to enable SSO for your workspace and connect your WorkOS-supported IdP, such as Okta, Azure AD, or Google SAML.

## IdP-initiated login

IdP-initiated login is supported. Users can start from the Runway tile in the IdP and continue into Runway.

## Domain enforcement and provider pinning

SSO enforcement is based on email domain. Users with matching email domains must use SSO. Outside collaborators, such as investors with non-matching domains, can still use Google, Microsoft, or another available login method.

A user who previously signed in through SSO is pinned to that provider.

## FAQ

<Accordion title="Can I mix SSO and non-SSO users?">
  Yes. SSO enforcement is by email domain, so matching domains use SSO while outside collaborators can use another available login method.
</Accordion>

<Accordion title="Can I configure SSO in Runway settings?">
  No. Runway configures SSO for your workspace. Contact support to enable it.
</Accordion>

<Accordion title="Which identity providers are supported?">
  Runway uses WorkOS, so WorkOS-supported IdPs such as Okta, Azure AD, and Google SAML can be connected.
</Accordion>

## What's next

* [Adding users](/guides/sharing/adding-users)
* [Permissions](/guides/sharing/permissions)
* [Roles and access](/reference/roles-and-access)


# NetSuite
Source: https://runway-docs.cfo.ai/integrations/accounting/netsuite

The NetSuite integration lets you automatically sync your financial data with Runway, eliminating manual data entry and ensuring your actuals stay up to date. With this connection, your financial models always reflect the latest numbers from NetSuite.

Runway supports an in-app quick-start connection and a SQL-powered Fivetran path for NetSuite. This page documents the Fivetran SuiteAnalytics path.

<Note>
  The quick-start connection starts from the in-app integration directory: go to **Settings → Integrations**, choose NetSuite, and follow the prompts. It syncs a standard set of tables; the rest of this page covers the SQL-powered Fivetran path.
</Note>

## Prerequisites

Before getting started, make sure you have:

1. A **NetSuite administrative account**
2. The [**SuiteAnalytics Connect Service**](https://docs.oracle.com/en/cloud/saas/netsuite/ns-online-help/book_N748613.html) enabled, with access to either the [**NetSuite.com**](http://NetSuite.com) or [**NetSuite2.com**](http://NetSuite2.com) data source.

## Setting up NetSuite via Fivetran

<img alt="Netsuite Fivetran Template" />

### Connecting the integration

1. Open your [Runway instance](https://v2.cfo.ai/).
2. In the left sidebar, hover over **Integrations** and click the **+** button to open the **Integrations Directory**.
3. Search for **NetSuite** and click **+ Set up** under the **Fivetran** option.
4. For the **Schema Name**, leave it as `netsuite_suiteanalytics`.

   <img alt="Netsuite Fivetran Schema" />
5. Click **Authorize** to be redirected to Fivetran to complete the connection.
6. Follow Fivetran’s setup instructions to finish configuring the integration.
7. Click **Save & Test** to begin syncing your data. You’ll be redirected back to Runway.

### Syncing your data into Runway

Runway provides **integration templates** to make it easy to bring in **Income Statement** and **Balance Sheet** data from NetSuite.

1. In the left sidebar, go to **Templates**.
2. Search for **NetSuite Data Import**.
3. Click **+ Add to Runway** on the template card.
4. This will automatically:
   * Add prebuilt **Income Statement** and **Balance Sheet** queries to your NetSuite integration.
   * Create the following databases in Runway:
     * **IS Data** (Income Statement)
     * **BS Data** (Balance Sheet)

<img alt="Netsuite Fivetran Template" />

## Supported data from NetSuite via Fivetran

When using the NetSuite **Data Import** integration template, the following financial data becomes available in Runway: **Income statement data**

| Data name                           | Example      | Data type     | Availability                                        |
| :---------------------------------- | :----------- | :------------ | :-------------------------------------------------- |
| Transaction Date                    | Mar 28, 2025 | Date Driver   | Via Template (used to group by Month in Timeseries) |
| Income Statement Amount (converted) | 15,000       | Number Driver | via Template                                        |
| Account Name                        | 200 Sales    | Dimension     | via Template                                        |
| Subsidiary                          | Acme         | Dimension     | via Template                                        |
| Department                          | Sales        | Dimension     | via Template                                        |
| Vendor Name                         | Microsoft    | Dimension     | via Template                                        |
| Class Full Name                     | Revenue      | Dimension     | via Template                                        |
| Account Type Name                   | Income       | Dimension     | via Template                                        |
| Parent Account Name                 | Sales        | Dimension     | via Template                                        |
| Account Number                      | 200          | Dimension     | Can be added                                        |
| Account Name (no number)            | Sales        | Dimension     | Can be added                                        |
| Vendor Category                     | Supplies     | Dimension     | Can be added                                        |
| Customer                            | John Doe     | Dimension     | Can be added                                        |
| Item ID                             | 123          | Dimension     | Can be added                                        |
| Item Name                           | Hosting      | Dimension     | Can be added                                        |
| Item Type Name                      | Service      | Dimension     | Can be added                                        |
| Location Name                       | ABC          | Dimension     | Can be added                                        |
| Location City                       | New York     | Dimension     | Can be added                                        |
| Location Country                    | US           | Dimension     | Can be added                                        |
| Currency Name                       | US Dollars   | Dimension     | Can be added                                        |
| Currency Symbol                     | USD          | Dimension     | Can be added                                        |

**Balance sheet data**

| Data name        | Example               | Data type     | Availability                                        |
| :--------------- | :-------------------- | :------------ | :-------------------------------------------------- |
| Account Name     | 1001 - Chase Checking | Dimension     | via Template                                        |
| Account Category | Asset                 | Dimension     | via Template                                        |
| Account Type     | Bank                  | Dimension     | via Template                                        |
| BS Amount        | 10,000                | Number Driver | via Template                                        |
| Month            | Mar 28, 2025          | Date Driver   | via Template (used to group by Month in Timeseries) |
| Subsidiary       | Acme Subsidiary       | Dimension     | Can be added                                        |

<Check>
  The **NetSuite Data Import** integration template includes the **most commonly used financial data**, but you can add **additional supporting data** to your database configurations for more detail if needed.
</Check>

## NetSuite FAQs

<Accordion title="Can you bring in custom columns, fields or lists from NetSuite?">
  Yes, absolutely. If you’re comfortable writing SQL, refer to our [SQL in Runway guide](/integrations/writing-sql) for instructions. If you’d prefer help from our team, feel free to reach out to CX. When you do, it’s helpful to come prepared with:

  * The name of the field(s) you'd like to pull.
  * Example data values from those fields.
  * What the field is associated with (e.g. Customer, Vendor, Transaction, or Transaction Line).
  * Bonus: A screenshot from NetSuite’s **Record Explorer** showing how the field is defined.

    <img alt="Netsuite Record Explorer" />
</Accordion>

<Accordion title="Can you bring in non-finance related data from NetSuite?">
  Yes. You’re not limited to just financial data—Runway can pull in operational, sales, or other business-critical data from NetSuite as well. To explore what’s available, check out:

  * Our [SQL in Runway guide](/integrations/writing-sql).
  * [This ERD](https://fivetran.com/docs/connectors/applications/netsuite-suiteanalytics#schemainformation) from our integration partner, Fivetran, which outlines the full set of accessible tables and fields.
</Accordion>

<Accordion title="Is SuiteAnalytics Connect required?">
  Yes. SuiteAnalytics Connect is essential for enabling a reliable integration with NetSuite. Without it, Runway cannot access your NetSuite data.

  Most customers already have this add-on enabled prior to starting with Runway. If you’re unsure whether it’s included in your plan, or need to enable it, reach out to NetSuite for details on access and pricing.
</Accordion>


# Puzzle
Source: https://runway-docs.cfo.ai/integrations/accounting/puzzle

Connect Puzzle accounting data to Runway for modeling and reporting.

Puzzle connects accounting data from Puzzle to Runway so you can use Puzzle actuals in financial models.

## Connecting Puzzle

Runway exposes Puzzle as an accounting integration named **Puzzle**.

<Steps>
  <Step title="Open Integrations">
    In Runway, open **Integrations** and choose **Browse all integrations**.
  </Step>

  <Step title="Choose Puzzle">
    Select **Puzzle** from the accounting integrations.
  </Step>

  <Step title="Authorize in Puzzle">
    Runway redirects you to Puzzle to approve the connection. After approval, Puzzle redirects back to Runway.
  </Step>
</Steps>

## Synced data

Runway imports Puzzle accounting snapshots for:

* Income Statement
* Balance Sheet
* Cash Flow Statement

The synced accounts appear as external accounting drivers in Runway and can be used like other integration-backed actuals.

## Puzzle FAQs

<Accordion title="Does Runway write data back to Puzzle?" icon="sparkles">
  No. Runway uses Puzzle as a source of accounting data for modeling and reporting.
</Accordion>

<Accordion title="Can I write SQL against Puzzle data in Runway?" icon="sparkles">
  Puzzle is a native accounting connection, not a SQL-powered Fivetran connection. Use the synced accounting drivers in Runway after the connection finishes syncing.
</Accordion>


# QuickBooks Online
Source: https://runway-docs.cfo.ai/integrations/accounting/quickbooks-online

The QuickBooks Online integration lets you automatically sync your financial data with Runway, eliminating manual data entry and ensuring your actuals stay up to date. With this connection, your financial models always reflect the latest numbers from QuickBooks.

Runway offers two ways to integrate with **QuickBooks Online**:

* **Quick-start connection** – A fast and simple setup.
* **SQL-powered integration via Fivetran (Recommended)** – For advanced data customization.

<Note>
  The quick-start connection starts from the in-app integration directory: go to **Settings → Integrations**, choose QuickBooks Online, and follow the prompts. It syncs a standard set of tables; the rest of this page covers the SQL-powered Fivetran path.
</Note>

## Setting up QuickBooks Online via Fivetran

<img alt="QuickBooks Fivetran" />

### Connecting the integration

1. Open your [Runway instance](https://v2.cfo.ai/).
2. In the left sidebar, hover over **Integrations** and click the **+** button to open the **Integrations Directory**.
3. Search for **QuickBooks** and click **+ Set up** under the **Fivetran** option.
4. For the **Schema Name**:
   * If connecting **a single QuickBooks instance**, leave it as `quickbooks`.
   * If connecting **multiple QuickBooks instances**, update the **Schema Name** with a unique identifier (e.g., `quickbooks_us`, `quickbooks_ltd`). <img alt="QuickBooks Fivetran Schema Name" />
5. Click **Authorize** to be redirected to Fivetran to complete the connection.
6. Follow Fivetran’s setup guide to finish configuring the integration.
7. Click **Save & Test** to begin syncing your data. You’ll be redirected back to Runway.

### Syncing your data into Runway

Runway provides **integration templates** to help you quickly import **Income Statement, Balance Sheet, and Cash Flow data** from QuickBooks Online, even with this SQL-powered integration.

1. In the sidebar, navigate to **Templates**.
2. Search for **QBO Data Import**.
3. Click **+ Add to Runway** on the template card.
4. The template will:
   * Automatically add **Income Statement** and **Combined Balance Sheet + Cash Flow** queries to the QuickBooks integration.
   * Create the following databases in Runway:
     * **IS Data** (Income Statement)
     * **BS Data** (Balance Sheet)
     * **CF Data** (Cash Flow)

<img alt="QuickBooks Template" />

## Supported data from QuickBooks Online via Fivetran

When using the **QBO Data Import** integration template, the following financial data becomes available in Runway: **Income statement data**

| Data name                   | Example                     | Data type     | Availability                                        |
| --------------------------- | --------------------------- | ------------- | --------------------------------------------------- |
| Transaction Date            | Mar 28, 2024                | Date driver   | Via Template - used to group by Month in timeseries |
| Income Statement Amount     | 15,000                      | Number driver | via Template                                        |
| Account Subtype             | SalesOfProductIncome        | Dimension     | via Template                                        |
| Account Type                | Income                      | Dimension     | via Template                                        |
| Class                       | East                        | Dimension     | via Template                                        |
| Customer                    | Acme Corp                   | Dimension     | Can be added                                        |
| Department                  | Sales                       | Dimension     | Can be added                                        |
| Financial Statement Helper  | income\_statement           | Dimension     | Can be added                                        |
| GL Account Name             | 4001 Revenue - Subscription | Dimension     | via Template                                        |
| GL Account Name (no number) | Revenue - Subscription      | Dimension     | Can be added                                        |
| GL Account Number           | 4001                        | Dimension     | Can be added                                        |
| GL Category                 | Revenue                     | Dimension     | via Template                                        |
| Parent GL Account Name      | 4000 - Revenue              | Dimension     | Can be added                                        |
| Parent GL Account Number    | 4000                        | Dimension     | Can be added                                        |
| Parent GL Name (no number)  | Revenue                     | Dimension     | Can be added                                        |
| Vendor                      | AWS                         | Dimension     | via Template                                        |

**Combined balance sheet & cash flow data**

| Data name                   | Example                  | Data type     | Availability                                        |
| --------------------------- | ------------------------ | ------------- | --------------------------------------------------- |
| BS Account Name             | 1001 - Chase Checking    | Dimension     | via Template                                        |
| Class Name                  | SG\&A                    | Dimension     | via Template                                        |
| Accounting Month            | Mar 2024                 | Date driver   | Via Template - used to group by Month in timeseries |
| Beginning Balance           | 500,000                  | Number driver | via Template                                        |
| Ending Balance              | 525,000                  | Number driver | via Template                                        |
| Net Change                  | 25,000                   | Number driver | via Template                                        |
| BS Account Type             | Bank                     | Dimension     | via Template                                        |
| BS Account Subtype          | Checking                 | Dimension     | via Template                                        |
| BS Account Number           | 1001                     | Dimension     | Can be added                                        |
| BS Account Name (no number) | Chase Checking           | Dimension     | Can be added                                        |
| BS Account Category         | Asset                    | Dimension     | via Template                                        |
| Cash Flow Type              | Cash or Cash Equivalents | Dimension     | via Template                                        |
| Parent BS Account Name      | 1000 - Cash              | Dimension     | Can be added                                        |
| Parent BS Account Number    | 1000                     | Dimension     | Can be added                                        |
| Is Sub-Account              | Yes                      | Dimension     | Can be added                                        |

<Check>
  The **QBO Data Import** integration template includes the **most commonly used financial data**, but you can add **additional supporting data** to your database configurations for more detail if needed.
</Check>

## QuickBooks Online FAQs

<Accordion title="Does Runway write data back to QuickBooks?" icon="sparkles">
  No, Runway supports **read-only** integrations. No data is written back to
  QuickBooks.
</Accordion>

<Accordion title="Can I connect multiple instances of QuickBooks Online?" icon="sparkles">
  Absolutely. To add additional instances, go to the **Integrations Directory** in Runway, click **Installed**, then select **Set Up**. Follow the same setup
  flow as outlined above for each additional instance.
</Accordion>

<Accordion title="Can I pull other types of data from QuickBooks?" icon="sparkles">
  Yes! Our integration is highly customizable. While the **QBO Data Import template** includes **starter queries** that fit most use cases, you can also **write your own SQL queries** leveraging [this QuickBooks
  schema](https://fivetran.com/docs/applications/quickbooks#schemainformation).
  Not a SQL expert? No problem—our **CX team** is happy to assist!
</Accordion>


# Xero
Source: https://runway-docs.cfo.ai/integrations/accounting/xero

The Xero integration allows you to automatically sync your financial data with Runway, eliminating manual data entry and ensuring your actuals stay up to date. With this connection, your financial models will always reflect the latest numbers from Xero.

Runway offers two ways to integrate with **Xero**:

* **Quick-start connection** – A fast and simple setup.
* **SQL-powered integration via Fivetran (Recommended)** – For advanced data customization.

<Note>
  The quick-start connection starts from the in-app integration directory: go to **Settings → Integrations**, choose Xero, and follow the prompts. It syncs a standard set of tables; the rest of this page covers the SQL-powered Fivetran path.
</Note>

## Setting up Xero via Fivetran

### Connecting the Integration

1. Open your [Runway instance](https://v2.cfo.ai/).
2. In the left sidebar, hover over **Integrations** and click the **+** button to open the **Integrations Directory**.
3. Search for **Xero** and click **+ Set up** under the **Fivetran** option.
4. For the **Schema Name**:
   * If connecting **a single Xero instance**, leave it as `Xero`.
   * If connecting **multiple Xero instances**, update the **Schema Name** with a unique identifier (e.g., `Xero_us`, `Xero_ltd`).
5. Click **Authorize** to be redirected to **Fivetran** to complete the connection.
6. Follow Fivetran’s **setup guide** to finish configuring the integration.
7. Click **Save & Test** to **begin syncing your data**. You’ll be redirected back to Runway.

<img alt="Xero" />

### Syncing your data into Runway

Runway provides **Integration Templates** to help you quickly import **Income Statement, Balance Sheet, and Cash Flow data** from Xero, even with this SQL-powered integration.

1. In the left sidebar, navigate to **Templates**.
2. Search for **Xero Data Import**.
3. Click **+ Add to Runway** on the template card.
4. The **Xero Data Import** template will:
   * Automatically add **Income Statement** and **Combined Balance Sheet + Cash Flow** queries to the Xero integration.
   * Create the following databases in Runway:
     * **IS Data** (Income Statement)
     * **BS Data** (Balance Sheet)
     * **CF Data** (Cash Flow)

<img alt="Xero Templates" />

## Supported data from Xero via Fivetran

When using the **Xero Data Import** integration template, the following financial data becomes available in Runway: **Income statement data**

| Data name                   | Example                     | Data type     | Availability                                        |
| --------------------------- | --------------------------- | ------------- | --------------------------------------------------- |
| Journal Date                | Mar 28, 2024                | Date Driver   | Via Template - used to group by Month in timeseries |
| Net IS Amount               | 15,000                      | Number Driver | via Template                                        |
| IS Account Name             | 4001 Revenue - Subscription | Dimension     | via Template                                        |
| IS Account Name (no number) | Revenue - Subscription      | Dimension     | Can be added                                        |
| IS Account Number           | 4001                        | Dimension     | Can be added                                        |
| IS Account Type             | SALES                       | Dimension     | via Template                                        |
| IS Account Category         | REVENUE                     | Dimension     | via Template                                        |
| Tracking Category           | 4000 - Revenue              | Dimension     | Can be added                                        |
| Tracking Category Option    | GTM                         | Dimension     | Can be added                                        |
| Contact Name                | Acme Corp                   | Dimension     | Can be added                                        |
| Source Transaction Type     | MANJOURNAL                  | Dimension     | Can be added                                        |

**Balance sheet data**

| Data name                        | Example               | Data type     | Availability                                        |
| -------------------------------- | --------------------- | ------------- | --------------------------------------------------- |
| Report Month                     | Mar 1, 2024           | Date Driver   | Via Template - used to group by Month in timeseries |
| BS Account Name                  | 1001 - Chase Checking | Dimension     | via Template                                        |
| BS Account Name (without number) | Chase Checking        | Dimension     | Can be added                                        |
| BS Account Number                | 1001                  | Dimension     | Can be added                                        |
| BS Account Type                  | BANK                  | Dimension     | via Template                                        |
| BS Account Category              | ASSET                 | Dimension     | via Template                                        |
| Net Balance                      | 500,000               | Number Driver | via Template                                        |

**Cash flow data**

| Data name                        | Example                 | Data type     | Availability                                        |
| -------------------------------- | ----------------------- | ------------- | --------------------------------------------------- |
| Journal Date                     | Mar 28, 2024            | Date Driver   | Via Template - used to group by Month in timeseries |
| CF Account Name                  | 2001 - Accounts Payable | String        | via Template                                        |
| CF Account Name (without number) | Accounts Payable        | Dimension     | Can be added                                        |
| CF Account Number                | 2001                    | Dimension     | Can be added                                        |
| CF Account Type                  | CURRLIAB                | Dimension     | via Template                                        |
| CF Account Category              | LIABILITY               | Dimension     | via Template                                        |
| CF Activity Type                 | Operating               | Dimension     | via Template                                        |
| Net Change                       | 10,000                  | Number Driver | via Template                                        |
| Source Transaction Type          | MANJOURNAL              | Dimension     | Can be added                                        |

<Check>
  The **Xero Data Import** integration template includes the **most commonly used financial data**, but you can add **additional supporting data** to your database configurations for more detail if needed.
</Check>

## Xero FAQs

<Accordion title="Does Runway write data back to Xero?" icon="sparkles">
  No, Runway supports **read-only** integrations. No data is written back to
  Xero.
</Accordion>

<Accordion title="Can I connect multiple instances of Xero?" icon="sparkles">
  Absolutely. To add additional instances, go to the **Integrations Directory** in Runway, click **Installed**, then select **Set Up**. Follow the same setup
  flow as outlined above for each additional instance.
</Accordion>

<Accordion title="Can I pull other types of data from Xero?" icon="sparkles">
  Yes! Our integration is highly customizable. While the **Xero Data Import
  template includes starter queries that fit most use cases**, you can also write your own SQL queries leveraging [this Xero
  schema](https://fivetran.com/docs/connectors/applications/xero#schemainformation).
  Not a SQL expert? No problem—our **CX team** is happy to assist!
</Accordion>


# Data warehouses
Source: https://runway-docs.cfo.ai/integrations/data-storage/data-warehouses

Runway integrates with a variety of data warehouse providers, allowing you to pull data that has already been processed, transformed, or sourced from systems that Runway does not integrate with directly.

## Supported data warehouses

We strongly support the following providers:

* **Snowflake** → [Setup guide](https://docs.workato.com/connectors/snowflake.html#how-to-connect-to-snowflake-on-workato)
* **Google BigQuery** → [Setup guide](https://docs.workato.com/connectors/bigquery.html#how-to-connect-to-bigquery-on-workato)
* **Amazon Redshift** → [Setup guide](https://docs.workato.com/connectors/redshift.html#how-to-connect-to-redshift-on-workato)

Setup guides are linked directly in **Runway**, but they are also available here for reference.

## Which integration to choose

Whenever possible, install the data warehouse which does **not** have **(Fivetran)** in the name. You want to choose the one under the **Data Warehouse section**.

<img alt="Data Warehouse Selection" />

The only exceptions to this rule are:

1. You wish to join your data warehouse data to Fivetran data directly in SQL.
2. You have multiple of the same data warehouses you need to connect (2+ Snowflake or 2+ Big Query data warehouses).

## How Runway connects to your data warehouse

Runway has an in-app **SQL editor** that allows us to query your data warehouse directly. To set up the connection:

1. **Create a user** for Runway in your data warehouse.
2. **Add our provider’s IP addresses** to your allowlist (found [here](https://docs.workato.com/security/ip-allowlists.html)).

<Info>
  Runway leverages the **US** data center.
</Info>

## Data warehouses FAQs

<Accordion title="How do I write SQL in Runway?" icon="sparkles">
  See our [help doc](/integrations/writing-sql).
</Accordion>

<Accordion title="What other databases can Runway pull from?" icon="sparkles">
  We also support **SQL databases** (via **Fivetran**) for:

  * **PostgreSQL**
  * **MySQL**
  * **SQL Server** (including **Azure, Google, and AWS-hosted** instances)
</Accordion>

<Accordion title="Is there a row limit on data queries?" icon="sparkles">
  Yes, each query must return fewer than **50,000 rows**.
</Accordion>

<Accordion title="How can I work around the row limit?" icon="sparkles">
  If your dataset exceeds **50,000 rows**, consider the following solutions:

  * **Aggregate data in SQL** → Use `SUM`, `GROUP BY`, or similar functions to reduce the row count.
  * **Limit the data scope** → Restrict queries by **time range** or other relevant filters.
  * **Split large datasets** → Break data into multiple **queries or databases** (e.g., by product line or geography).
</Accordion>

<Accordion title="Are there any IP addresses I need to add to an allowlist?" icon="sparkles">
  Yes, please see [here](https://docs.workato.com/security/ip-allowlists.html). We are currently only leveraging US data centers.
</Accordion>


# File upload
Source: https://runway-docs.cfo.ai/integrations/data-storage/file-upload

Runway's File Upload integration allows you to quickly import CSV files directly into Runway for use in modeling.

You may choose to use File Upload if:

* You need to **import data quickly** without setting up a full integration.
* You have **CSV files** from systems that don't have direct integrations.
* You want to **test data** in Runway before committing to a full integration setup.
* You have **one-time data imports** that don't require ongoing syncing.

## File requirements

Before uploading your CSV file, ensure it meets these requirements:

* **File format**: Only `.csv` files are supported.
* **File size**: Maximum file size is **50MB**.
* **Data structure**: The first row should contain column headers.
* **Data quality**: Ensure at least one data row exists below the headers.
* **Date format**: Use **MM/DD/YYYY** format for date columns (e.g., `01/15/2024`).

<Tip>
  For best results, clean your CSV file before uploading—remove extra blank rows, ensure consistent column headers, and format dates as **MM/DD/YYYY** (e.g., `01/15/2024`).
</Tip>

## Connecting the File Upload integration

1. Open Runway and navigate to **Integrations**.
2. Find and install the **File Upload** integration listed under the **Data storage** section.
3. A new query called **New File Upload** will be automatically created.
4. You can rename this query by clicking the **three-dots button** next to the query name in the sidebar and selecting **Rename query**.

## Uploading a CSV file

Once you've connected the File Upload integration:

1. Click on your File Upload query in the sidebar.
2. In the query editor, you'll see a file upload interface.
3. Click **Choose File** and select your CSV file (must be `.csv` format and under 50MB).
4. The file will upload automatically. You'll see a confirmation message when the upload is complete.
5. Click **Run query** to import the data into Runway.

<Warning>
  File uploads must be run manually. Unlike other integrations, File Upload queries cannot be scheduled to sync automatically.
</Warning>

## Refreshing data

To update the data in your File Upload query:

1. Upload a new CSV file using the same steps above.
2. Click **Run query** to refresh the data.
3. The new data will replace the previous data in your linked database.

<Info>
  Each time you upload a new file and run the query, it completely replaces the previous data. Make sure your new file contains all the data you need.
</Info>

## Using uploaded data in databases

After running your File Upload query:

1. [Configure a new database](/concepts/databases/databases-basics#configuring-a-database) linked to your File Upload query.
2. The database will display the data from your CSV file.
3. You can now use this data in your models, pages, and formulas just like any other integration.

## File upload FAQs

<Accordion title="Can I schedule File Upload queries to sync automatically?" icon="sparkles">
  No. File Upload queries must be run manually. If you need automatic syncing, consider using [Google Sheets](/integrations/data-storage/google-sheets) or a [data warehouse](/integrations/data-storage/data-warehouses) integration instead.
</Accordion>

<Accordion title="What happens if my CSV file is larger than 50MB?" icon="sparkles">
  Files larger than 50MB cannot be uploaded. You'll need to either:

  * **Split your file** into smaller CSV files and create multiple File Upload queries.
  * **Aggregate your data** before exporting to reduce the file size.
  * Use a [data warehouse](/integrations/data-storage/data-warehouses) integration for larger datasets.
</Accordion>

<Accordion title="Can I upload multiple CSV files to the same query?" icon="sparkles">
  No. Each File Upload query can only contain data from one CSV file at a time. When you upload a new file and run the query, it replaces the previous data. If you need to import multiple CSV files, create separate File Upload queries for each file.
</Accordion>

<Accordion title="What CSV formats are supported?" icon="sparkles">
  Runway supports standard CSV files with:

  * **Comma-separated values** (`,` as delimiter)
  * **Column headers** in the first row
  * **At least one data row** below the headers
  * **Date columns** formatted as **MM/DD/YYYY** (e.g., `01/15/2024`)

  The CSV parser is flexible and handles quoted fields and leading/trailing spaces automatically.
</Accordion>

<Accordion title="Why isn't my uploaded file showing data?" icon="sparkles">
  If you don't see data after uploading and running the query, check:

  * Your CSV file has **column headers** in the first row.
  * There is **at least one data row** below the headers.
  * The file is **properly formatted** as a CSV (not Excel or other formats).
  * You clicked **Run query** after uploading the file.
</Accordion>

<Accordion title="Can I edit the CSV data directly in Runway?" icon="sparkles">
  No. File Upload queries are read-only. To modify the data, you need to:

  1. Edit your CSV file outside of Runway.
  2. Upload the updated CSV file.
  3. Click **Run query** to refresh the data.
</Accordion>


# Google Sheets
Source: https://runway-docs.cfo.ai/integrations/data-storage/google-sheets

Runway’s Google Sheets integration allows you to pull in additional data that isn’t available through direct integrations.

You may choose to integrate Google Sheets if:

* You need to **import historical data** that isn’t stored in any other system.
* There’s **no direct integration available** for a specific data source, and Google Sheets acts as a bridge.
* You have **manual inputs** that are easier to maintain in a spreadsheet before bringing them into Runway.

## Understanding Google Sheets data format

Runway supports two primary formats when importing from Google Sheets: **long data** and **wide data**. Understanding these structures will help you choose the right import method.

### Long data

**Long data** is structured so that each row represents a specific transaction or balance on a particular date. When preparing your Google Sheets data for Runway, ensure it follows a structure similar to the example below:

<img alt="Sheets Long Data" />

### Wide data

**Wide data** is structured in a columnar format, where the first few columns define the type of data (e.g., account, category), and the remaining columns represent month-by-month balances. This format is commonly used for Income Statement or Balance Sheet exports from accounting systems.

When preparing your Google Sheets data for Runway, ensure it follows a structure similar to the example below:

<img alt="Sheets Wide Data" />

## Before you start

Before importing your Google Sheet into Runway, ensure it's clean and correctly formatted to avoid errors. Follow these best practices:

* **Remove extra blank rows and columns** — No empty rows **above, in between, or below** your data table.
  * Every column should contain **at least one data point** — empty columns will not be imported.
* **Use clear and simple column headers** — Make headers **short and readable** (e.g., use `"account_name"` instead of `"Account Name (MAPPED)"`).
  * Use **consistent naming** for key fields (e.g., `"is_balance_sheet"` instead of `"Balance Sheet?"`).
* **Format date columns properly**
  * **Long data**: Use **MM/DD/YYYY** format.
  * **Wide data**: Ensure month column headers are in one of these **supported formats**:`"Jan-2006"`, `"Jan 2006"`, `"Jan_2006"`, `"January 2006"`, `"01/2006"`, `"01/06"`, `"01_06"`, `"01_2006"`, `"01-2006"`, `"2006-01"`.
  * [Here’s a Loom on how to format dates correctly](https://www.loom.com/share/d5cedfd346ff4bb296d36eff23fbe5ee).
* **Ensure numerical data is in proper format** — Remove **currency symbols (\$, €)** and **percent signs (%)** — values should be **pure numbers**.
  * **Wide data**: Replace blanks with `0` to maintain consistency.
  * [Here’s a Loom on how to quickly fill blanks](https://www.loom.com/share/08aeb90722de429185de299e03a10b45).

## Connecting a Google Sheet with wide data

[Here’s a video walkthrough of these steps](https://www.loom.com/share/efb88c97c6154ebc92f4a7ff9cb4a1b4).

<Tip>
  Ensure your Google Sheet is less than 10,000 rows. If your wide data set has more than 10,000 rows follow [this guide](https://www.loom.com/share/e9d99cbc625f4f639acea12edced7acd).
</Tip>

1. Open Runway, navigate to **Integrations**, and install the Google Sheets integration listed under the **Spreadsheets** section.

   <img alt="Sheets Spreadsheet" />
2. Click **Sign in with Google** and leave the other settings as default.

   <img alt="Sheets Spreadsheet Setup" />
3. Once redirected back into **Runway**, click **+** next to integration name in the sidebar to create a new query.

   <img alt="Create Query" />
4. You can then change the default query name, **New query**, to something more descriptive. To do this, click the **three-dots button** next to the query name in the sidebar and select **Rename query**.

   <img alt="Rename Query" />
5. In **Google Sheets**, navigate to the tab you want to import into Runway. Add `#runway` to the tab name to ensure Runway recognizes it.

   <img alt="Sheets Spreadsheet Tab" />
6. Copy the **Spreadsheet ID** from the URL:
   1. Example URL:

      ```bash theme={null}
      https://docs.google.com/spreadsheets/d/1gk-Y0tJ64TDCak_z2ELqKHmR9rmqY0f5XR27H-ksxKY/edit?gid=0#gid=0

      ```
   2. The Spreadsheet ID is everything between `/d/` and `/edit/`:

      ```bash theme={null}
      1gk-Y0tJ64TDCak_z2ELqKHmR9rmqY0f5XR27H-ksxKY

      ```
7. Paste the **Spreadsheet ID** into Runway and click **Run Query**.

   <img alt="Sheets Spreadsheet Id" />
8. Verify the data preview:
   * If you see a column named **month** and a column named **value**, Runway successfully converted your **wide data** into a **long data set**.
   * If you see separate columns for each month, there may be formatting issues in your Google Sheet. Refer to the **video walkthrough** at the top of this section for troubleshooting.
9. You’re all set! [Now configure a new database.](/concepts/databases/databases-basics#configuring-a-database)

## Connecting a Google Sheet with long data

[Here’s a video walkthrough of these steps](https://www.loom.com/share/a6f08d1a57884baebd702697c6f9f807).

1. Open **Runway**, navigate to **Integrations**, and install the **Google Sheets integration** listed under the **Fivetran** section.

   <img alt="Sheets Fivetran" />
2. Leave the **Schema Name** as the default and enter a **Table Name** that accurately represents the data.

   * **Do not include spaces or special characters** in the table name.
   * Click **Authorize**.

   <img alt="Sheets Fivetran Setup" />
3. You’ll be redirected to **Fivetran** to complete the setup.
4. Under **Authentication Method**, choose **Authorize Service Account**, then copy the email address provided by Fivetran.
5. In **Google Sheets**, open your spreadsheet in a **new tab** and **share it with that email address** as a **viewer**.
6. Select the **headers of the data you want to import** (they must be side by side—**you cannot skip columns**) and create a **named range.** Navigate to **Data > Named Range**, then give it a **unique and descriptive name**.

   <img alt="Data Range" />
7. Copy the **entire URL** of your Google Sheet. For example:

   ```bash theme={null}
   https://docs.google.com/spreadsheets/d/1XVd9Qx7UdCiNaRXVPyBCJn_0eMQKF-qq193_KC4hyos/edit?gid=0#gid=0

   ```
8. Go back to **Fivetran** and paste this URL into the **Sheet URL** section.
9. Click **Find sheet** and select the **named range** you just created.
10. Click **Save & Test**.
11. You’ll be redirected back to **Runway**, where it may take a few minutes for the data sync to complete.
12. Once the sync is complete, click into your **Google Sheets Integration** in Runway.
13. Rename **New Query** to something descriptive by clicking the **three-dots button** next to the query name in the sidebar and select **Rename query**.
14. Copy the **suggested commented query**, paste it below in the SQL editor, and click **Run query**.

    <img alt="Sheets Fivetran Commented Query" />
15. You’re done! [Now configure a new database.](/concepts/databases/databases-basics#configuring-a-database)

## Google Sheets FAQs

<Accordion title="Can I integrate multiple tabs from a single Google Sheet into Runway?" icon="sparkles">
  Yes. Follow the **Long data integration** instructions and set up multiple integrations—one for each tab you need. Each integration must be configured separately.
</Accordion>

<Accordion title="Can I integrate long data without using the Fivetran version?" icon="sparkles">
  Yes, but the **non-Fivetran version only supports one tab at a time and 10,000 rows** per integration. If you need multiple tabs, either **create separate spreadsheets** or specify the tab Runway should pull from by adding #runway to the tab name.
</Accordion>

<Accordion title="Why is my column not showing up in Runway?" icon="sparkles">
  Runway only pulls columns that **contain data**. If a column is empty, it won’t be imported. To fix this, **add some dummy data**, run the integration, and then remove the dummy values afterward.
</Accordion>

<Accordion title="How often does this sheet sync to Runway?" icon="sparkles">
  The sync runs **automatically every morning (US Pacific Time)**. You can also **manually trigger a sync** like this:

  <img alt="Resync" />
</Accordion>

<Accordion title="Can the Fivetran version also sync wide data?" icon="sparkles">
  Yes, but it’s a bit trickier because Fivetran **sometimes modifies column names**. To prevent issues, make sure your **date column headers use the format MON\_YYYY**. [Here’s a video walkthrough](https://www.loom.com/share/e9d99cbc625f4f639acea12edced7acd).
</Accordion>


# Shared directories
Source: https://runway-docs.cfo.ai/integrations/data-storage/shared-directory

Runway integrates with a variety of file-sharing services, allowing you to seamlessly import data from external systems that may not have direct integrations with Runway. 

These integrations let you **manually or automatically schedule exports** from other tools and have Runway **pull in the data automatically**.

## Supported file storage services

Runway supports the following file storage and shared directory providers:

* **Google Drive** → [Setup guide](https://fivetran.com/docs/connectors/files/google-drive/setup-guide)
* **Microsoft OneDrive** → [Setup guide](https://fivetran.com/docs/connectors/files/one-drive/setup-guide)
* **Dropbox** → [Setup guide](https://fivetran.com/docs/connectors/files/dropbox/setup-guide)
* **Box** → [Setup guide](https://fivetran.com/docs/connectors/files/box/setup-guide)
* **Amazon S3** → [Setup guide](https://fivetran.com/docs/connectors/files/amazon-s3/setup-guide)
* **Azure Blob Storage** → [Setup guide](https://fivetran.com/docs/connectors/files/azure-blob-storage/setup-guide)
* **Google Cloud Storage** → [Setup guide](https://fivetran.com/docs/connectors/files/google-cloud-storage/setup-guide)
* **FTP** → [Setup guide](https://fivetran.com/docs/connectors/files/ftp)
* **SFTP** → [Setup guide](https://fivetran.com/docs/connectors/files/sftp)

## FAQs

<Accordion title="How do I write SQL in Runway?" icon="sparkles">
  See this [help doc](/integrations/writing-sql).
</Accordion>

<Accordion title="How often do these integrations sync to Runway?" icon="sparkles">
  By default, file storage integrations **sync daily in the morning (US Pacific Time).** You can also **manually trigger a sync** like this:

  <img alt="Resync" />
</Accordion>


# Export API
Source: https://runway-docs.cfo.ai/integrations/export-api

Runway offers a limited API to allow you to export model and database views programmatically.

Use the Export API when you need the same CSV-style output available from Runway, but pulled programmatically.

## Supported objects

The Export API supports model pages and database pages. Generic pages are not supported by the server and return **Pages cannot be exported.**

Example Runway URLs:

* Main scenario model: `https://v2.cfo.ai/your-org-slug/submodel/afd94c7e-1e7f-4e55-b99a-472aa5a43cd9`
* Scenario model: `https://v2.cfo.ai/your-org-slug/proposal/445f8fea-df2a-49cb-9cce-f805be588137/submodel/afd94c7e-1e7f-4e55-b99a-472aa5a43cd9`
* Main scenario database: `https://v2.cfo.ai/your-org-slug/page/5fb5f2a6-7a13-4085-a89c-86e2da66a17c`
* Scenario database: `https://v2.cfo.ai/your-org-slug/proposal/445f8fea-df2a-49cb-9cce-f805be588137/page/5fb5f2a6-7a13-4085-a89c-86e2da66a17c`

## Exporting with the API

<Steps>
  <Step title="Create an API secret">
    In Runway settings, open **API** and create or copy your API secret.
  </Step>

  <Step title="Set the authorization header">
    Send the secret as a bearer token:

    ```txt theme={null}
    Authorization: Bearer <your API secret>
    ```
  </Step>

  <Step title="Build the API URL">
    Start from the model or database URL, remove the org slug, and use `https://runway-api.cfo.ai/api`.

    ```txt theme={null}
    https://v2.cfo.ai/your-org-slug/submodel/afd94c7e-1e7f-4e55-b99a-472aa5a43cd9
    https://runway-api.cfo.ai/api/submodel/afd94c7e-1e7f-4e55-b99a-472aa5a43cd9
    ```
  </Step>

  <Step title="Send a GET request">
    Use `GET` for the export request.
  </Step>
</Steps>

Supported URL paths:

* `/api/submodel/:pageID`
* `/api/proposal/:layerID/submodel/:pageID`
* `/api/page/:pageID`
* `/api/proposal/:layerID/page/:pageID`

## Response shape

The response is JSON with:

| Field      | Description               |
| ---------- | ------------------------- |
| `filename` | Suggested CSV filename.   |
| `contents` | CSV contents as a string. |

## Limitations

* Export uses the same model or database view that Runway can export to CSV.
* The time period comes from the page or block configuration.
* Formulas are not exported as formulas; the export returns CSV data.
* The request must come from a user with export permission. If the user does not have permission, Runway returns **You do not have the permissions to export this page.**

For manual exports from the app, see [Exporting CSVs](/integrations/exporting-csv).


# Exporting to CSV
Source: https://runway-docs.cfo.ai/integrations/exporting-csv

Export Runway data to CSV when you need spreadsheet-ready output.

CSV exports give you spreadsheet-ready output from models, databases, driver tables, charts, and raw query results. Use them when you need to analyze Runway data outside the app or share a static extract with another workflow.

## Export a block

Database table blocks, driver grid blocks, and chart blocks include **Export to CSV** in the block menu. This option is also available in read-only views when you have export access.

<Steps>
  <Step title="Open the block menu">
    Open the menu for the database table block, driver grid block, or chart block.
  </Step>

  <Step title="Export">
    Select **Export to CSV**.
  </Step>

  <Step title="Save the file">
    Runway downloads a CSV for the block.
  </Step>
</Steps>

The filename uses `<Page> - <Block> - <Layer>.csv`. If the block name is unavailable, Runway falls back to `<Page> - <Layer>.csv`.

## Export a page-level CSV

Page-level **Export to CSV** is offered from the topbar page actions menu and the sidebar right-click menu for database pages and model pages with read access. Generic pages cannot be exported as a page-level CSV.

<Steps>
  <Step title="Open the page actions menu">
    Open a database page or model page.
  </Step>

  <Step title="Choose export">
    Select **Export to CSV**.
  </Step>

  <Step title="Save the file">
    Runway downloads the CSV using the page and scenario context.
  </Step>
</Steps>

## Date range

CSV exports use the block's configured date range. When a block does not define a date range, Runway uses the default window of 12 months before last actuals through 6 months after.

## Export raw query results

Each data-source query's settings includes **Export CSV**. Use it when you need the raw query result rather than the shaped model or page output.

## Permissions

Export requires export permission. Guests can export where they have been granted export access. If you do not have access, Runway shows **You do not have the permissions to export this page.**

## FAQ

<Accordion title="Can I export from read-only mode?">
  Yes. Block-level **Export to CSV** is available in read-only views when export access is permitted.
</Accordion>

<Accordion title="Can every page be exported?">
  No. Page-level export is offered for database pages and model pages. Generic pages cannot be exported page-level.
</Accordion>

<Accordion title="Can I exclude external tables from a CSV export?">
  No. Runway does not offer an exclude-ext-tables option for CSV export.
</Accordion>

## What's next

* [Export API](/integrations/export-api)
* [Database block](/concepts/pages/database-block)
* [Drivers table block](/concepts/pages/drivers-table-block)


# Deel
Source: https://runway-docs.cfo.ai/integrations/hris/deel

Connect Deel to Runway to automatically sync your employee data. Keep your workforce information up to date and easily incorporate headcount and salaries into your financial models.

<Note>
  Runway currently supports connecting to only one HRIS account at a time. For multi-entity setup across systems, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Note>

## Connecting to Deel

Follow these steps to integrate **Deel** with Runway and automatically sync your HR data:<img alt="Deel" />

1. Open your [Runway instance](https://v2.cfo.ai/).

2. In the sidebar, hover over Integrations and click the **+** button to open the **Integrations Directory**.

3. Search for **Deel** and click **+ Set up** under the **HRIS** option.

4. Choose your authentication method:

   * **Use my credentials (recommended)** – Follow the prompts to be redirected to Deel’s website and complete authentication.

   * **Use my API key or access token** – Follow the onscreen instructions to generate an API key.

5. Once authentication is complete, a confirmation message will appear, and the initial sync will begin automatically.

6. When the sync is finished, a new **Employee database** will appear in your Runway sidebar, containing the imported data.

## Deel supported data

Runway automatically imports the following data from **Deel.**

| Data name        | Example           | Runway data type  |
| ---------------- | ----------------- | ----------------- |
| Name             | John Smith        | *Name*            |
| Title            | Software Engineer | *Dimension Field* |
| Team             | Engineering       | *Dimension Field* |
| Pay Rate         | \$100,000         | *Number Field*    |
| Pay Period       | YEAR              | *Dimension Field* |
| Pay Currency     | USD               | *Dimension Field* |
| Type             | SALARIED\_FT      | *Dimension Field* |
| Office           | Remote            | *Dimension Field* |
| Department       | Engineering       | *Dimension Field* |
| Start Date       | Jul 1, ‘24        | *Date Field*      |
| Termination Date | Jan 1, ‘25        | *Date Field*      |

## Deel FAQs

<Accordion title="Is there a difference between the two authentication methods?">
  Only in how they verify your identity. Both methods provide a complete sync of the data listed above.
</Accordion>

<Accordion title="Does Runway write data back to Deel?">
  No, Runway supports **read-only** integrations. No data is written back to Deel.
</Accordion>

<Accordion title="Does the Deel integration send only base salary values or fully-loaded employee costs?">
  Runway currently only syncs **base salary** values for each employee.
</Accordion>

<Accordion title="Can I connect additional HRIS sources?">
  Runway supports only one active HRIS connection at a time. For the current multi-entity limitation, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Accordion>


# Gusto
Source: https://runway-docs.cfo.ai/integrations/hris/gusto

Connect Gusto to Runway to automatically sync your employee data. Keep your workforce information up to date and easily incorporate headcount and salaries into your financial models.

<Note>
  Runway currently supports connecting to only one HRIS account at a time. For multi-entity setup across systems, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Note>

## Connecting to Gusto

Follow these steps to connect **Gusto** to Runway and automatically sync your employee data:<img alt="Gusto" />

1. Open your [Runway instance](https://v2.cfo.ai/).
2. In the left sidebar, hover over **Integrations** and click the **+** button to open the **Integrations Directory**.
3. Search for **Gusto** and click **+ Set up** under the **HRIS** option.
4. Follow the onscreen prompts to **sign into Gusto** and authorize the connection.
5. Once authentication is complete, a confirmation message will appear, and the **initial sync will begin automatically**.
6. When the sync is finished, a new **Employee database** will appear in your **Runway sidebar**, containing the imported data.

## Gusto supported data

Runway automatically imports the following data from **Gusto**.

| Data name        | Example           | Runway data type  |
| ---------------- | ----------------- | ----------------- |
| Name             | John Smith        | *Name*            |
| Title            | Software Engineer | *Dimension Field* |
| Team             | Engineering       | *Dimension Field* |
| Pay Rate         | \$100,000         | *Number Field*    |
| Pay Period       | YEAR              | *Dimension Field* |
| Pay Currency     | USD               | *Dimension Field* |
| Type             | SALARIED\_FT      | *Dimension Field* |
| Office           | Remote            | *Dimension Field* |
| Department       | Engineering       | *Dimension Field* |
| Start Date       | Jul 1, ‘24        | *Date Field*      |
| Termination Date | Jan 1, ‘25        | *Date Field*      |

## Gusto FAQs

<Accordion title="Does Runway write data back to Gusto?">
  No, Runway supports **read-only** integrations. No data is written back to Gusto.
</Accordion>

<Accordion title="Does the Gusto integration send only base salary values or fully-loaded employee costs?">
  Runway currently only syncs **base salary** values for each employee.
</Accordion>

<Accordion title="Can I connect additional HRIS sources?">
  Runway supports only one active HRIS connection at a time. For the current multi-entity limitation, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Accordion>


# Hibob
Source: https://runway-docs.cfo.ai/integrations/hris/hibob

Connect Hibob to Runway to automatically sync your employee data. Keep your workforce information up to date and easily incorporate headcount and salaries into your financial models.

<Note>
  Runway currently supports connecting to only one HRIS account at a time. For multi-entity setup across systems, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Note>

## Connecting to Hibob

<img alt="Hibob" />

1. Open your [Runway instance](https://v2.cfo.ai/).

2. In the left sidebar, hover over **Integrations** and click the **+** button to open the **Integrations Directory**.

3. Search for **Hibob** and click **+ Set up** under the **HRIS** option.

4. Follow the onscreen prompts to **connect a Hibob Service Account**.

5. Once authentication is complete, a confirmation message will appear, and the **initial sync will begin automatically**.

6. When the sync is finished, a new **Employee database** will appear in your **Runway sidebar**, containing the imported data.

## Hibob supported data

Runway automatically imports the following data from **Hibob.**

| Data name        | Example           | Runway data type  |
| ---------------- | ----------------- | ----------------- |
| Name             | John Smith        | *Name*            |
| Title            | Software Engineer | *Dimension Field* |
| Team             | Engineering       | *Dimension Field* |
| Pay Rate         | \$100,000         | *Number Field*    |
| Pay Period       | YEAR              | *Dimension Field* |
| Pay Currency     | USD               | *Dimension Field* |
| Type             | SALARIED\_FT      | *Dimension Field* |
| Office           | Remote            | *Dimension Field* |
| Department       | Engineering       | *Dimension Field* |
| Start Date       | Jul 1, ‘24        | *Date Field*      |
| Termination Date | Jan 1, ‘25        | *Date Field*      |

## Hibob FAQs

<Accordion title="Does Runway write data back to Hibob?">
  No, Runway supports **read-only** integrations. No data is written back to Hibob.
</Accordion>

<Accordion title="Does the Hibob integration send only base salary values or fully-loaded employee costs?">
  Runway currently only syncs **base salary** values for each employee.
</Accordion>

<Accordion title="Can I connect additional HRIS sources?">
  Runway supports only one active HRIS connection at a time. For the current multi-entity limitation, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Accordion>


# Justworks
Source: https://runway-docs.cfo.ai/integrations/hris/justworks

Connect Justworks to Runway to automatically sync your employee data, ensuring your workforce information stays up to date. 

<Note>
  Runway currently supports connecting to only one HRIS account at a time. For multi-entity setup across systems, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Note>

## Connecting to Justworks

Follow these steps to connect **Justworks** to Runway and automatically sync your employee data:<img alt="Justworks" />

1. Open your [Runway instance](https://v2.cfo.ai/).

2. In sidebar, hover over **Integrations** and click the **+** button to open the **Integrations Directory**.

3. Search for **Justworks** and click **+ Set up** under the **HRIS** option.

4. Follow the onscreen prompts to create and connect a **Justworks Service Account**.

5. Once authentication is complete, a confirmation message will appear, and the **initial sync will begin automatically**.

6. When the sync is finished, a new **Employee database** will appear in your Runway sidebar, containing the imported data.

## Justworks supported data

Runway automatically imports the following data from **Justworks**.

| Data name        | Example           | Runway data type  |
| ---------------- | ----------------- | ----------------- |
| Name             | John Smith        | *Name*            |
| Title            | Software Engineer | *Dimension Field* |
| Team             | Engineering       | *Dimension Field* |
| Pay Rate         | \$100,000         | *Number Field*    |
| Pay Period       | YEAR              | *Dimension Field* |
| Pay Currency     | USD               | *Dimension Field* |
| Type             | SALARIED\_FT      | *Dimension Field* |
| Office           | Remote            | *Dimension Field* |
| Department       | Engineering       | *Dimension Field* |
| Start Date       | Jul 1, ‘24        | *Date Field*      |
| Termination Date | Jan 1, ‘25        | *Date Field*      |

## Justworks FAQs

<Accordion title="My connection keeps failing. How should I troubleshoot?">
  1. In **Justworks**, delete any **Service Accounts** that have attempted to connect to Runway.

  2. In **Runway**, delete the **Justworks integration**.

  3. Repeat the setup process:

     * Create a **new Service Account** in Justworks.

     * Grant it **all permissions**.

     * Connect it to Runway.
</Accordion>

<Accordion title="Does Runway write data back to Justworks?">
  No, Runway supports **read-only** integrations. No data is written back to Justworks.
</Accordion>

<Accordion title="Can I connect additional HRIS sources?">
  Runway supports only one active HRIS connection at a time. For the current multi-entity limitation, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Accordion>

<Accordion title="Does the Justworks integration send only base salary values or fully-loaded employee costs?">
  Runway currently only syncs **base salary** values for each employee.
</Accordion>


# Rippling
Source: https://runway-docs.cfo.ai/integrations/hris/rippling

Connect Rippling to Runway to automatically sync your employee data, keeping workforce information up to date and seamlessly incorporating headcount and salaries into your financial models.

Runway offers two ways to integrate with Rippling:

* **Quick-Start connection (Recommended)** – A fast and simple setup.

* **SQL-powered integration via Fivetran** – For advanced data customization.

For the SQL-powered path, follow the [SQL guide](/integrations/writing-sql) after connecting Rippling through Fivetran.

<Note>
  Runway currently supports connecting to only one HRIS account at a time. For multi-entity setup across systems, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Note>

## Setting up Rippling via quick-start

<img alt="Rippling" />

1. Open your [Runway instance](https://v2.cfo.ai/).

2. In the sidebar, hover over **Integrations** and click the **+** button to open the **Integrations Directory**.

3. Search for **Rippling** and click **+ Set up** under the **HRIS** option.

4. You’ll be redirected to **Rippling**. **Sign in** to authenticate and complete the setup questions.

5. Click **Continue** to finish setup. A confirmation message will appear, and the **initial sync will begin automatically**.

6. Once the sync is complete, a new **Employee database** will appear in your Runway sidebar, containing the imported data.

## Rippling supported data

Runway automatically imports the following data from Rippling.

| Data name                      | Example           | Runway data Type  |
| ------------------------------ | ----------------- | ----------------- |
| Name                           | John Smith        | *Name*            |
| Title                          | Software Engineer | *Dimension Field* |
| Team                           | Engineering       | *Dimension Field* |
| Pay Rate                       | \$100,000         | *Number Field*    |
| Pay Period                     | YEAR              | *Dimension Field* |
| Pay Currency                   | USD               | *Dimension Field* |
| Type                           | SALARIED\_FT      | *Dimension Field* |
| Office                         | Remote            | *Dimension Field* |
| Department                     | Engineering       | *Dimension Field* |
| Start Date                     | Jul 1, ‘24        | *Date Field*      |
| Termination Date               | Jul 1, ‘25        | *Date Field*      |
| Target Annual Bonus            | \$0.00            | *Number Field*    |
| Target Annual Bonus Percentage | 0%                | *Number Field*    |
| On Track Commission            | \$0.00            | *Number Field*    |

## Rippling FAQs

<Accordion title="If I enable login authentication for Runway via Rippling, do I still need to set up the Rippling integration through Runway to enable the data sync?">
  Yes. Login authentication and integration authentication are separate. You still need to set up the Rippling integration in Runway to sync data.
</Accordion>

<Accordion title="Does Runway write data back to Rippling?">
  No, Runway supports read-only integrations. No data is written back to Rippling.
</Accordion>

<Accordion title="Does the Rippling integration send only base salary values or fully-loaded employee costs?">
  Runway currently only syncs base salary values for each employee.
</Accordion>

<Accordion title="Can I connect additional HRIS sources?">
  Runway supports only one active HRIS connection at a time. For the current multi-entity limitation, see [Multi-entity integrations](/integrations/multi-entity-integrations).
</Accordion>


# Integrations directory
Source: https://runway-docs.cfo.ai/integrations/integrations-directory

Use the integrations directory to understand Runway's supported connection routes and where to bring in data when a source is not directly listed.

Runway offers direct integrations for common accounting, HRIS, revenue, CRM, warehouse, spreadsheet, and file-based workflows. In the app, open **Integrations** and choose **Browse all integrations** to see the live directory for your workspace.

For a source-by-source list of currently documented routes, see the [Integration catalog](/reference/integration-catalog).

## Gold

Gold integrations are the most commonly used and well-tested paths. They are reliable, widely understood, and typically take only a day or two to set up, either through a self-serve flow or with light guidance from the Runway team.

1. ADP Workforce Now
2. BambooHR
3. Google Ads
4. Google BigQuery
5. Google Sheets
6. Gusto
7. Hibob
8. HubSpot
9. Justworks
10. NetSuite SuiteAnalytics
11. Paylocity
12. Pipedrive
13. Puzzle
14. QuickBooks Online
15. Redshift
16. Rippling
17. Salesforce
18. Snowflake
19. Stripe
20. Xero

## Silver

Silver integrations are supported, but setup may require more detail about your data shape, connection route, or modeling use case.

1. Airtable
2. Amazon S3
3. Azure Blob Storage
4. Chargebee
5. Deel
6. Google Analytics
7. IntelliHR
8. Looker
9. Oracle
10. Ramp
11. REST
12. Tableau
13. TriNet
14. Zuora

## Other data sources

Runway does not expose the full Fivetran connector universe as a supported in-app catalog. If your source is not listed in Runway, bring the data in through one of these paths:

* [Data warehouses](/integrations/data-storage/data-warehouses) for sources you already land in Snowflake, Redshift, Google BigQuery, or another supported warehouse.
* [Google Sheets](/integrations/data-storage/google-sheets) when a spreadsheet is the cleanest bridge.
* [CSV / Raw File Upload](/integrations/data-storage/file-upload) for manual imports and one-off datasets.
* Your own Fivetran account, then expose the prepared data through a warehouse or another supported import path.

Use the live in-app directory when you need to confirm whether an integration is available in your workspace.


# Intro to integrations
Source: https://runway-docs.cfo.ai/integrations/intro-to-integrations

Import data automatically from your Accounting, HRIS, Revenue, and many other platforms. Say goodbye to manual data entry and keep your actuals up to date with real-time syncing.

## Overview

Integration data is the foundation of building in Runway. In this article, we’ll walk through how data flows from your connected sources into Runway—at the right level of granularity—so you can build with accuracy and confidence.

## How Runway connects to your data

Runway offers **two ways** to connect to external data sources. Some integrations support **both** methods, while others are available through only one.

### Option 1: Quick-start integrations

* These integrations provide an **easy, no-code connection**.
* Ideal for getting started quickly with structured data.
* **Best for:** standardized datasets that don’t require customization (i.e. HRIS)

### Option 2: Flexible, SQL-powered integrations via Fivetran

* Allows for **deeper, more customizable data pulls** using SQL queries.
* Requires additional setup but provides more **granularity and control** over imported data.
* **Best for:** Integrations that need custom data fields or more detailed reporting (i.e. Accounting, CRM, Data Warehouse).

<Check>
  Runway provides default queries for many of our most popular SQL-Powered integrations to help with setup. And our team is also available to assist!
</Check>

For our most popular integrations, we’ll provide a **recommended setup** on its dedicated page—so you’ll always know the best option to start with.

* [Accounting integrations setup](/integrations/accounting/quickbooks-online)
* [HRIS integrations setup](/integrations/hris/rippling)
* [Revenue integrations setup](/integrations/revenue/hubspot)
* [Data & storage integrations setup](/integrations/data-storage/file-upload)
* [Full integrations directory](/integrations/integrations-directory)


# Multi-entity integrations
Source: https://runway-docs.cfo.ai/integrations/multi-entity-integrations

Runway supports multi-entity integrations through our dimensional modeling approach. The most common use case is consolidating financials across entities via your General Ledger integration—for example, connecting multiple QuickBooks Online or Xero accounts.

<Check>
  NetSuite already has robust support for multi-entities, typically this works out of the box with our Income Statement & Balance Sheet templates as the Subsidiary is already included.
</Check>

## How it works in Runway

Runway allows you to connect **multiple instances** of most integrations—including duplicate QuickBooks or Xero accounts. Once the connections are established, our CX team will work with you to label each entity appropriately and **combine the data into a single database** on your behalf.

<Warning>
  Runway currently supports connecting to only one HRIS account at a time. For example, if you have two Rippling accounts, we can connect to just one of them per Runway account. If this limitation affects you, please contact us directly.
</Warning>

## The SQL behind multi-entity

Our team is happy to handle this setup for you—especially if you’re not comfortable with SQL. But if you’re curious how it works or want to do it yourself, read on.

In this example, we’ll walk through combining multiple **QuickBooks Online** entities using SQL. The same approach applies for **Xero**.

1. Follow the [Fivetran setup guide for QuickBooks](/integrations/accounting/quickbooks-online) and install the standard **QuickBooks Template** to set up your first entity.
2. Install the integration for each additional entity, but don't apply the template again. When prompted for a schema name, use a unique identifier for each entity (e.g., `quickbooks_us`, `quickbooks_ltd`).
   <img alt="Reinstall" />
3. After completing the setup, locate the **Income Statement Data** query from the template installed in the first step.
   <img alt="Locate Query" />
4. We will need to edit this query to combine each QuickBooks Online data source and insert the matching subsidiary as a new column. Here’s an example code snippet of how to accomplish this. The key pieces to note are:

   * You're writing **one SELECT per schema**.
   * You're tagging each row with a **subsidiary name**.
   * You’re combining them with **UNION ALL**.

   ```sql theme={null}
   WITH main_query AS (
     SELECT
       TRANSACTION_DATE AS "Transaction Date",
       ADJUSTED_CONVERTED_AMOUNT AS "Income Statement Amount",

       -- Account Info
       COALESCE(gl.account_number || ' ', '') || COALESCE(ACCOUNT_NAME, 'No Account Name') AS "GL Account Name",
       gl.ACCOUNT_NUMBER AS "GL Account Number",
       ACCOUNT_NAME AS "GL Account Name (no number)",
       ACCOUNT_TYPE AS "Account Type",
       ACCOUNT_SUB_TYPE AS "Account Subtype",
       ACCOUNT_CLASS AS "GL Category",
       FINANCIAL_STATEMENT_HELPER AS "Financial Statement Helper",

       -- Drill-in Detail
       cu.display_name AS "Customer",
       v.display_name AS "Vendor",
       cl.name AS "Class",
       d.name AS "Department",

       -- Parent Account
       PARENT_ACCOUNT_NUMBER AS "Parent GL Account Number",
       COALESCE(parent_account_number || ' ', '') || COALESCE(parent_ACCOUNT_NAME, 'No Account Name') AS "Parent GL Account Name",
       PARENT_ACCOUNT_NAME AS "Parent GL Name (no number)",

       'Main' AS Subsidiary

     FROM quickbooks_quickbooks.quickbooks__general_ledger gl
     LEFT JOIN quickbooks.customer cu ON gl.customer_id = cu.id
     LEFT JOIN quickbooks.vendor v ON gl.vendor_id = v.id
     LEFT JOIN quickbooks.class cl ON gl.class_id = cl.id
     LEFT JOIN quickbooks.department d ON gl.department_id = d.id

     WHERE transaction_date > '2022-12-31'
       AND financial_statement_helper LIKE '%income_statement%'
   ),
   llc_query AS (
     SELECT
       TRANSACTION_DATE AS "Transaction Date",
       ADJUSTED_CONVERTED_AMOUNT AS "Income Statement Amount",

       -- Account Info
       COALESCE(gl.account_number || ' ', '') || COALESCE(ACCOUNT_NAME, 'No Account Name') AS "GL Account Name",
       gl.ACCOUNT_NUMBER AS "GL Account Number",
       ACCOUNT_NAME AS "GL Account Name (no number)",
       ACCOUNT_TYPE AS "Account Type",
       ACCOUNT_SUB_TYPE AS "Account Subtype",
       ACCOUNT_CLASS AS "GL Category",
       FINANCIAL_STATEMENT_HELPER AS "Financial Statement Helper",

       -- Drill-in Detail
       cu.display_name AS "Customer",
       v.display_name AS "Vendor",
       cl.name AS "Class",
       d.name AS "Department",

       -- Parent Account
       PARENT_ACCOUNT_NUMBER AS "Parent GL Account Number",
       COALESCE(parent_account_number || ' ', '') || COALESCE(parent_ACCOUNT_NAME, 'No Account Name') AS "Parent GL Account Name",
       PARENT_ACCOUNT_NAME AS "Parent GL Name (no number)",

       'LLC' AS Subsidiary

     FROM quickbooks_llc_quickbooks.quickbooks__general_ledger gl
     LEFT JOIN quickbooks_llc.customer cu ON gl.customer_id = cu.id
     LEFT JOIN quickbooks_llc.vendor v ON gl.vendor_id = v.id
     LEFT JOIN quickbooks_llc.class cl ON gl.class_id = cl.id
     LEFT JOIN quickbooks_llc.department d ON gl.department_id = d.id

     WHERE transaction_date > '2022-12-31'
       AND financial_statement_helper LIKE '%income_statement%'
   )

   SELECT * FROM main_query
   UNION ALL
   SELECT * FROM llc_query;
   ```
5. Paste your updated SQL into Runway’s SQL editor and click **Run query** to make sure everything runs as expected.
   <img alt="Run Query" />
6. The final step is to add the new **Subsidiary** field to the shaped database. Navigate to the database connected to your Income Statement (labeled **IS data** if you used the template), click Edit, select the dropdown next to **Segment by,** and check **Subsidiary**>**Confirm**.
   <img alt="Consolidate Db" />
7. That's it! You can apply the same process to consolidate your Balance Sheet and Cash Flow databases.

## Intercompany eliminations

When you combine multiple entities into a single dataset, what you’re really creating is a **combined view** — not a fully consolidated one. To build a true **consolidated P\&L**, you’ll often want to **exclude intercompany eliminations** so those transactions don’t artificially inflate your totals.

The simplest way to handle this in Runway is by:

1. **Creating a lookup** table that maps each GL account to a new dimension—something like `Elimination Type` or `Is Intercompany`.
2. In that dimension, flag whether each account should be treated as an intercompany elimination.
3. When building your **consolidated P\&L**, just add a filter to exclude any rows where the account is flagged as an intercompany elimination.
4. When building **subsidiary-level P\&Ls**, you can ignore that flag entirely—this gives you the flexibility to report both combined and entity-level.

## Multi-entity FAQ

<Accordion title="Can I consolidate entities from different accounting systems (for example, Google Sheets, QuickBooks Online, and Xero)?">
  Yes. You can connect each system to Runway using our **Fivetran integration**, then follow the SQL pattern outlined above to consolidate the data.

  Keep in mind: these systems often use **different table names, column names, and schemas**. You’ll need to carefully map the equivalent fields from each source into a common structure. This requires a bit of SQL proficiency. **Need help?** Our CX team is happy to support you through the process.
</Accordion>

<Accordion title="I have a query with multiple entities combined. How do I configure a database to only include data from one entity?">
  1. Open the database → click **Edit**.
  2. Add a filter on the **entity/subsidiary** column.
  3. To filter for a single entity, just enter its exact name.
  4. To include **multiple entities**, use **comma-separated values without spaces**, like: `business1,business2,business3`.
     <img alt="Shaping Filter" />
</Accordion>


# HubSpot
Source: https://runway-docs.cfo.ai/integrations/revenue/hubspot

The HubSpot integration allows you to automatically sync your deals and revenue data into Runway.

Runway offers two ways to integrate with **HubSpot**:

* **SQL-powered integration via Fivetran (Recommended)** – Ideal if you need advanced data customization and want to pull in a wide range of HubSpot objects (like Deals, Owners, Accounts, Users, and more).
* **Quick-start connection via Workato** – A simpler setup, but limited in scope. For example, it supports only a subset of HubSpot objects, such as Deals, and doesn't allow you to pull in related context like Owner, Account, or User data.

## SQL-powered integration via Fivetran (Recommended)

1. Click **Setup** on the **HubSpot (Fivetran)** integration in the Integrations directory and follow the on-screen authentication process.

   <img alt="Hubspot Fivetran" />
2. When prompted in **Fivetran**, select **Sync all historical data** for the sync time frame.

   <img alt="Hubspot Fivetran Scope" />
3. After being redirected back to **Runway**, we recommend using our **HubSpot Deal Quickstart** integration template.

   * In the left sidebar, navigate to **Templates**.
   * Search for **HubSpot Deal Quickstart**.
   * Click **+ Add to Runway** to apply the template.

   <img alt="Hubspot Fivetran Template" />
4. This template automatically creates a database for you to begin building your model.
5. Alternatively, you can follow our [SQL guide](/integrations/writing-sql) to customize the existing quick-start template or pull additional objects and properties. Note that when referencing HubSpot properties in your query, you must use their internal names, which differ from the display names shown in the HubSpot interface.
   * To find available properties, go to HubSpot settings (⚙️) → Data Management → Properties → Select the relevant object (e.g., deal)
   * From this list, search for the specific property you want to add to Runway, such as deal name.

     <img alt="Hubspot Property" />
   * Click the property to find its internal name. When writing your SQL, search for a property with a matching name.

     <img alt="Hubspot Property Internal Name" />

## Quick-start connection via Workato

1. Open your [Runway instance](https://v2.cfo.ai/).
2. In the left sidebar, hover over **Integrations** and click the **+** button to open the Integrations Directory.
3. Under the **Other** section, search for **HubSpot** and click **+ Set up** on the option listed in **Others** section.

   <img alt="Fivetran Workato" />
4. You'll be redirected to HubSpot to authorize the connection and complete authentication.
5. Once authorized, you'll return to Runway. Click **+** next to the integration name in the sidebar to create a new query.

   <img alt="Create Query" />
6. You can then change the default query name, **New query**, to something more descriptive. To do this, click the **three-dots button** next to the query name in the sidebar and select **Rename query**.

   <img alt="Rename Query" />
7. In the query form, you can select the **HubSpot object** you want to work with (**Deals** is the most commonly used), and the **properties** you want to pull for that object.

   <img alt="Hubspot Workato Form" />
8. Note that for **properties**, you must use their internal names, which differ from the display names shown in the HubSpot interface.
   * To find the list of available properties, in **HubSpot**, navigate to **Settings (⚙️) → Data Management → Properties** and select the matching object (e.g., Deals).
   * In this list, search for the property you wish to add to Runway, for example, deal name.

     <img alt="Hubspot Property" />
   * Click into the property and find the internal name.

     <img alt="Hubspot Property Internal Name" />
9. Type that internal name into the Runway properties field and press Enter.
10. Repeat for all desired fields for that object.
11. Once completed, click Run query and validate the data looks correct.
12. You’re done integrating! [Go ahead and configure a new database.](/concepts/databases/databases-basics)

## HubSpot FAQs

<Accordion title="How do I write SQL in Runway?">
  See this [help doc](/integrations/writing-sql).
</Accordion>

<Accordion title="What objects does Runway have access to?">
  Our Fivetran integration has access to all standard HubSpot objects and
  fields. HubSpot data can be complex, and writing queries can sometimes be
  challenging. If you need help pulling specific data, reach out to our
  team—we’re happy to assist.
</Accordion>

<Accordion title="How does a deal land in a time series?">
  It’s fully customizable—you can map each deal based on dates such as creation
  date, close date, or contract start date. You can also use Runway’s built-in
  functionality to pull values forward into future periods. This is a common use
  case, so feel free to contact our team for guidance.
</Accordion>


# Salesforce
Source: https://runway-docs.cfo.ai/integrations/revenue/salesforce

The Salesforce integration allows you to automatically sync your deals and revenue data into Runway.

Runway offers two ways to integrate with **Salesforce**:

* **Quick-start connection via Workato (Recommended)** – A simpler setup that leverages existing Salesforce reports you’ve built.
* **SQL-powered integration via Fivetran** – Ideal if you need advanced data customization and want to pull in a wide range of Salesforce objects (like Opportunities, Accounts, Users, and more).

## Quick-start connection via Workato (Recommended)

<Info>
  This integration method relies on you having existing Salesforce reports configured. Please be aware of the following:

  1. Any filters applied to that report will automatically apply to the data imported into Runway.
  2. Salesforce Reports must be configured in a simple row based format, no charts, no pivots.
  3. This integration path is limited to 2k rows of data. If you need more, we recommend Fivetran (below) or multiple reports.
</Info>

1. Open your [Runway instance](https://v2.cfo.ai/).
2. In the left sidebar, hover over **Integrations** and click the **+** button to open the Integrations Directory.
3. Search for **Salesforce** and click **+ Set up** on the option listed in the **CRM** section.

   <img alt="Salesforce Workato" />
4. You’ll be redirected to Salesforce to authorize the connection and complete authentication.
5. Once authorized, you’ll return to Runway. Click **+** next to the integration name in the sidebar to create a new query.

   <img alt="Create Query" />
6. You can then change the default query name, **New query**, to something more descriptive. To do this, click the **three-dots button** next to the query name in the sidebar and select **Rename query**.

   <img alt="Rename Query" />
7. Copy the **Salesforce Report ID** from your report's URL and paste it into the highlighted field below.

   <img alt="Salesforce Workato Report Id" />
8. Click Run query and validate the data looks correct.
9. You’re done integrating! [Go ahead and configure a new database.](/concepts/databases/databases-basics)

## SQL-powered integration via Fivetran

1. Click **Setup** on the **Salesforce (Fivetran)** integration in the Integrations directory and follow the on-screen authentication process.

   <img alt="Salesforce Fivetran" />
2. Keep the default settings during Fivetran setup.

   <img alt="Salesforce Fivetran Config" />
3. After being redirected back to **Runway**, we recommend using our **Salesforce Opportunities** integration template.

   * In the left sidebar, navigate to **Templates**.
   * Search for **Salesforce Opportunities Quickstart**.
   * Click **+ Add to Runway** to apply the template.

   <img alt="Salesforce Fivetran Template" />
4. This template automatically creates a database for you to begin building your model.
5. Alternatively, you can follow our [SQL guide](/integrations/writing-sql) to customize the existing template or pull additional objects and properties. Note that when referencing Salesforce properties in your query, **you must use their internal names**, which may differ from the display names shown in the Salesforce interface.

## Salesforce FAQs

<Accordion title="How do I write SQL in Runway?">
  See this [help doc](/integrations/writing-sql).
</Accordion>

<Accordion title="What objects does Runway have access to?">
  Our Fivetran integration has access to all standard & custom Salesforce objects and fields. Salesforce data can be complex, and writing queries can sometimes be challenging. If you need help pulling specific data, reach out to our team—we’re happy to assist.
</Accordion>

<Accordion title="How does a deal land in a time series?">
  It’s fully customizable—you can map each deal based on dates such as creation date, close date, or contract start date. You can also use Runway’s built-in functionality to [propagate values forward](/guides/modeling/propagating-sparse-data) into future periods. This is a common use case, so feel free to contact our team for guidance.
</Accordion>

<Accordion title="How do I pull in a calculated/formula field?">
  If you are using Workato, this will come in through your report automatically.

  If you are using Fivetran, there is a query you can use `select * from salesforce.fivetran_formula_model` which stores the SQL to replicate your formulas. If the formula changes in Salesforce, you will need to update your query to use the correct formula in Runway too.
</Accordion>


# Stripe
Source: https://runway-docs.cfo.ai/integrations/revenue/stripe

The Stripe integration allows you to automatically sync your balance, payment & subscriber data directly into Runway.

## SQL-powered integration via Fivetran

1. Click **Setup** on the **Stripe (Fivetran)** integration in the Integrations directory and follow the on-screen authentication process.

   <img alt="Stripe Fivetran" />
2. When prompted to specify the **Historical sync time frame** in Fivetran, select **Sync all historical data**.
   * You’ll need to log into Stripe as an admin to create an API key.
   * Be sure to create a **Restricted Key**.
   * Grant **read access** to all resources you intend to pull into Runway.
     * Without the appropriate permissions, we may not be able to access all required data.
     * [Here’s a full reference of Stripe permission scopes.](https://docs.stripe.com/stripe-apps/reference/permissions#object)
3. Enter the API key in Fivetran, click **Save & Test** to complete setup, and you’ll be redirected back to Runway.

   <Warning>
     Stripe imposes strict API rate limits. The **initial sync may take a few days** to complete the full historical data sync.
   </Warning>
4. Once the sync is complete, use our pre-built Stripe templates:

   * In the left sidebar, navigate to **Templates**.
   * Search for **Stripe Balance Transactions**.
   * Click **+ Add to Runway** to apply the template and get started quickly.

   <img alt="Stripe Templates" />
5. Alternatively, you can follow our [SQL guide](/integrations/writing-sql) to customize the existing template or pull additional objects and properties.

## Stripe FAQs

<Accordion title="How do I write SQL in Runway?">
  See this [help doc](/integrations/writing-sql).
</Accordion>

<Accordion title="How do I calculate my New/Upgrade/Downgrade/Churn each month?">
  1. Start with the Stripe MRR quickstart. It’s available from the in-app template picker during Stripe setup.
  2. In the database, create a new column for New, Upgrade, Downgrade and Churn.
  3. Use Runway formulas to calculate this value based on the MRR amount for each line each month. Our CX team can offer guidance here if you get stuck.
     1. New MRR is: If MRR last month = 0 and MRR this month > 0, New MRR = MRR this month
     2. Upgrade is: If MRR this month > MRR last month and MRR last month ≠ 0, Upgrade MRR = MRR this month - MRR last month
     3. Downgrade is: If MRR this month \< MRR last month and MRR this month ≠ 0, Downgrade MRR = MRR this month - MRR last month
     4. Churn is: If MRR this month = 0 and MRR last month ≠0, Churn MRR = MRR last month
</Accordion>

<Accordion title="How do I pull my revenue recognition schedule from Stripe?">
  We cannot pull this from Stripe at this time. You may be able to calculate it using CRM data or SQL.
</Accordion>

<Accordion title="Why doesn’t my data match the Stripe dashboard?">
  Review the SQL and make any adjustments needed. Unfortunately, Stripe does not provide a way to exactly replicate the metrics from their dashboard, and our templates represent our best effort to match them. Please let our team know of any discrepancies—we're happy to check the data.
</Accordion>


# Writing SQL in Runway
Source: https://runway-docs.cfo.ai/integrations/writing-sql

Runway allows you to write SQL directly within the app to pull, shape, and transform data based on your needs. This feature is available for integrations using one of our supported data warehouses or any of our Fivetran integrations.

This guide is designed for users with **SQL experience** or for **data teams** assisting business users in integrating data into Runway. If you're new to SQL, consider learning through resources like [Snowflake’s SQL introduction](https://docs.snowflake.com/en/learn-tutorials).

## Identifying a Fivetran integration

There are two ways to check if your integration is powered by Fivetran:

1. **During setup** – The integration will display the **Fivetran** label when being installed.
   <img alt="Fivetran tag" />
2. **After installation** – If already installed, you can check by looking at the **URL** in the query editor.
   <img alt="Fivetran URL" />

## Adding a new query

For integrations that support SQL queries, you can click **+** next to integration name in the sidebar to create a new query.

<img alt="Create Query" />

You can then change the default query name, **New query**, to something more descriptive. To do this, click the **three-dots button** next to the query name in the sidebar and select **Rename query**.

<img alt="Rename Query" />

## Writing SQL for data warehouses

When querying **data warehouses** (non-Fivetran integrations), you must use the SQL syntax of the provider:

* **Google BigQuery** – Uses **GoogleSQL**
* **Snowflake** – Supports **standard SQL**
* **Amazon Redshift** – Uses **PostgreSQL**

Runway **automatically runs your queries every morning (US Pacific Time)**, updating any dependent databases, models, and pages. Queries run directly against your data warehouse, so results match what you’d get if you queried locally in that system.

You can **manually refresh** data at any time by going into the query and selecting **Run query.**

<img alt="Run Query" />

<Warning>
  You **cannot** write SQL to **join data warehouse sources with Fivetran integrations** within Runway.
</Warning>

## Writing SQL for Fivetran integrations

All **Fivetran integrations** are stored in **Runway’s Snowflake data warehouse**, meaning all SQL queries must follow [Snowflake-supported syntax](https://docs.snowflake.com/en/guides-overview-queries).

To explore available data, open the **query editor** in Runway for a Fivetran integration and run:

```sql theme={null}
SHOW TABLES
```

This command will list **all schemas and tables** available for querying. If you have **multiple** **Fivetran integrations**, you will see matching tables and schemas across different integrations, allowing you to join multiple Fivetran sources together.

<img alt="Show Tables" />

**Runway automatically syncs data daily:**

1. Data is **pulled from your source system** into Runway’s **Snowflake data warehouse** every morning (US Pacific Time).

2. Runway then **automatically** **executes integration queries** shortly after to refresh the data in your model. **If you need an immediate manual refresh:**

3. Manually trigger a sync from your source system.
   <img alt="Resync" />

4. Once the source data is refreshed, **rerun your SQL queries manually** to update your model. This step ensures the newly synced data appears in your model.
   <img alt="Run Query" />

## Best practices & tips

* **Structure your queries to return a long dataset** — a list of **transactions, accounts, or metrics** with a **daily or monthly amount**. This format ensures flexibility for modeling. Example:

  | dimension\_1 | dimension\_..x | date\_1    | date\_..x  | value\_1 | value\_..x |
  | ------------ | -------------- | ---------- | ---------- | -------- | ---------- |
  | Account 1    | Asset          | 01/01/2025 | 03/01/2025 | 10       | 20         |
  | Account 2    | Liability      | 01/02/2025 | 04/01/2025 | 30       | 40         |
* **Include all dimensions, dates, or values needed** — not all of them need to be used in the final database configuration.
* **Aggregate/roll up data to the minimum level required** for modeling and drill-downs. For example, if pulling general ledger data, and only monthly spend per account is needed, **write your query to pre-aggregate** the data:
  * Avoid this

    ```
    select
    	account,
    	transaction_amount,
    	transaction_date
    from general_ledger

    ```
  * Do this

    ```
    select
    	account,
    	sum(transaction_amount) as transaction_amount,
    	date_trunc('month',transaction_date) transaction_month
    from general_ledger
    group by 1,3

    ```
* **Filter out unwanted data** — some Fivetran tables contain columns like `_fivetran_deleted`. Filtering out these records helps prevent duplicate records in your dataset.

Now that your queries are complete and your integration is set up, [learn how to shape a database.](/concepts/databases/databases-basics#configuring-a-database)


# Errors & troubleshooting
Source: https://runway-docs.cfo.ai/reference/errors-troubleshooting

Diagnose common Runway errors and learn where to go next.

Use this reference when a formula cell, database refresh, or modeled value does not behave as expected. Start with the visible label or symptom, then check the likely cause and fix.

## Formula errors

| Error label | What it means                                                                                                                                           | Example                                                                   | How to fix                                                                                                                             |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| `TYPE`      | The tooltip says: "This driver, or one of its formula inputs, is performing an operation across incompatible types or resolves to a non numeric value." | A Number driver uses `dateAdd()` and returns a date.                      | Change the driver to a Date driver, or change the formula so it returns a number.                                                      |
| `CIRC`      | The driver depends on itself in the same period, directly or through another formula.                                                                   | Revenue references Total revenue, while Total revenue references Revenue. | Remove the self-referential dependency. If the logic should use a prior period, reference the prior period instead of the current one. |

## Blank or unexpected values

### Null vs. zero

Runway treats `NULL` and `0` differently. `0` is an explicit value. `NULL` means no value was returned. Features such as **Most recent value** can pull forward the last known non-null value, but they do not replace an explicit zero.

For more examples, see [Propagating sparse data](/guides/modeling/propagating-sparse-data).

### Date-range misalignment

If a formula returns values in some months but not others, check the time range on the referenced driver or database field. A filter can exclude the month you are evaluating, and an integration-derived value may only exist in months where the source system returned data.

### Actuals vs. forecast boundary

Actuals formulas apply through [last close](/concepts/last-close). Forecast formulas apply after last close. If a value changes when you move last close, check whether the actuals formula, forecast formula, or a hardcoded value is winning for that month.

## Data refresh issues

### Data source health

Each data source's actions menu shows its refresh health. **Healthy** appears with the last-sync time. **Disconnected** or **Log in to resume updates** means Runway cannot refresh that source until the connection is restored.

### Circular dependency blocks refresh

Some database refreshes can be blocked by a dependency cycle between databases. The alert title is **Circular dependency blocks refresh**, with summary **These databases depend on one another, so Runway cannot refresh them automatically.**

The alert can show a **LOOP** section with the cycle path joined by **→**, plus **DETAILS** such as **depends on**, **Through**, and **Fields**. Break the cycle by changing the database formulas or configuration so one database no longer depends on another database that depends back on it.

## Getting help

If you are still blocked, email [support@cfo.ai](mailto:support@cfo.ai) with the error label, the driver or database name, the scenario you are in, and the formula or data source you were editing.

## What's next

* [Formulas basics](/concepts/formulas/formulas-basics)
* [Functions & operators](/concepts/formulas/functions-operators)
* [Last close](/concepts/last-close)


# Integration catalog
Source: https://runway-docs.cfo.ai/reference/integration-catalog

Review the integrations Runway offers and the route each connection uses.

Use the integration catalog to confirm which sources Runway offers directly and which route each connection uses before planning an import.

## Accounting

| Integration                        | Connection route | Notes                                                     |
| ---------------------------------- | ---------------- | --------------------------------------------------------- |
| NetSuite                           | Workato          | SQL-queryable                                             |
| NetSuite SuiteAnalytics (Fivetran) | Fivetran         | SQL-queryable                                             |
| Puzzle                             | native           |                                                           |
| QuickBooks Online                  | Merge            | Multi-account support; Merge passthrough SQL when enabled |
| Xero                               | Merge            | Multi-account support; Merge passthrough SQL when enabled |
| Xero                               | native           | Multi-account support; Unified Xero connection route      |
| Xero (Fivetran)                    | Fivetran         | Multi-account support; SQL-queryable                      |

## HRIS

| Integration                  | Connection route | Notes                 |
| ---------------------------- | ---------------- | --------------------- |
| ADP Workforce Now            | Merge            |                       |
| Altera Payroll               | Merge            |                       |
| BambooHR                     | Merge            |                       |
| Breathe                      | Merge            |                       |
| Charlie                      | Merge            |                       |
| ChartHop                     | Merge            |                       |
| ClayHR                       | Merge            |                       |
| Dayforce                     | Merge            |                       |
| Deel                         | Merge            |                       |
| Factorial                    | Merge            |                       |
| Freshteam                    | Merge            |                       |
| Google Workspace             | Merge            |                       |
| Gusto                        | Merge            |                       |
| Hibob                        | Merge            |                       |
| HR Cloud                     | Merge            |                       |
| HR Partner                   | Merge            |                       |
| Humaans                      | Merge            |                       |
| Insperity Premier            | Merge            |                       |
| IntelliHR                    | Merge            |                       |
| JumpCloud                    | Merge            |                       |
| Justworks                    | Merge            |                       |
| Kallidus                     | Merge            |                       |
| Keka                         | Merge            |                       |
| Lano                         | Merge            |                       |
| Lucca                        | Merge            |                       |
| Microsoft Entra ID           | Merge            |                       |
| Namely                       | Merge            |                       |
| Nmbrs                        | Merge            |                       |
| Officient                    | Merge            |                       |
| Okta                         | Merge            |                       |
| OneLogin                     | Merge            |                       |
| PayCaptain                   | Merge            |                       |
| Paychex                      | Merge            |                       |
| Paycom                       | Merge            |                       |
| Paycor                       | Merge            | Multi-account support |
| Paylocity                    | Merge            |                       |
| PeopleHR                     | Merge            |                       |
| Personio                     | Merge            |                       |
| Proliant                     | Merge            |                       |
| Rippling                     | native           |                       |
| Sage HR                      | Merge            |                       |
| SAP SuccessFactors           | Merge            |                       |
| Sesame                       | Merge            |                       |
| Simployer                    | Merge            |                       |
| Square Payroll               | Merge            |                       |
| TriNet                       | Merge            |                       |
| TriNet HR Platform           | Merge            |                       |
| UKG Pro                      | Merge            |                       |
| UKG Pro Workforce Management | Merge            |                       |
| UKG Ready                    | Merge            |                       |
| Workday                      | Merge            |                       |
| Zoho People                  | Merge            |                       |

## Revenue & CRM

| Integration           | Connection route | Notes         |
| --------------------- | ---------------- | ------------- |
| HubSpot               | Workato          |               |
| HubSpot (Fivetran)    | Fivetran         | SQL-queryable |
| HubSpot default       | Workato          |               |
| Pipedrive             | Workato          |               |
| Salesforce            | Workato          |               |
| Salesforce (Fivetran) | Fivetran         | SQL-queryable |

## Data storage & warehouses

| Integration              | Connection route | Notes                              |
| ------------------------ | ---------------- | ---------------------------------- |
| Airtable                 | Workato          |                                    |
| Amazon S3                | Workato          |                                    |
| Azure Blob Storage       | Workato          |                                    |
| CSV / Raw File Upload    | native           | Bring CSV or raw files into Runway |
| Google BigQuery          | Workato          | SQL-queryable                      |
| Google Sheets            | Workato          |                                    |
| Google Sheets (Fivetran) | Fivetran         | SQL-queryable                      |
| Redshift                 | Workato          | SQL-queryable                      |
| REST                     | Workato          |                                    |
| Runway API               | native           |                                    |
| Snowflake                | Workato          | SQL-queryable                      |

## Other

| Integration             | Connection route | Notes |
| ----------------------- | ---------------- | ----- |
| AWS Cost Explorer       | Workato          |       |
| Chargebee               | Workato          |       |
| Coupa                   | Workato          |       |
| Facebook Lead Ads       | Workato          |       |
| Google Ads              | Workato          |       |
| Google Analytics        | Workato          |       |
| Looker                  | Workato          |       |
| Oracle                  | Workato          |       |
| Oracle Financials Cloud | Workato          |       |
| Ramp                    | Workato          |       |
| Stripe                  | Workato          |       |
| Tableau                 | Workato          |       |
| Zuora                   | Workato          |       |

If your source is not listed here, bring the data into Runway through your warehouse, Google Sheets, CSV or raw file upload, or your own Fivetran account. Runway does not expose the full Fivetran connector universe as a supported catalog.

Catalog note: the webapp multi-account configuration still includes Zenefits, but Zenefits is not in the current Merge offered catalog.


# Roles and access
Source: https://runway-docs.cfo.ai/reference/roles-and-access

Compare Runway organization roles, default capabilities, and resource access levels.

Use roles and access levels together when you need to decide what someone can do in a workspace and on a specific shared resource.

## Organization roles

Runway roles are strictly hierarchical: Owner > Admin > Manager > Member > Guest > Anonymous user. A user's role caps what per-resource access can grant.

| Role           | Product description                                                                          |
| -------------- | -------------------------------------------------------------------------------------------- |
| Owner          | No product description encoded.                                                              |
| Admin          | Can configure the model, workspace settings, and all workspace info.                         |
| Manager        | Can trace and edit models, create scenarios, and access shared information in the workspace. |
| Member         | Can trace models, create scenarios, and access shared information in the workspace.          |
| Guest          | Can view pages and data that have been shared with them.                                     |
| Anonymous user | No product description encoded.                                                              |

## Default capability matrix

This matrix shows the default system ACLs seeded for each role. A check means the default ACL grants that capability; a dash means it is not granted by the default ACL or is explicitly denied.

| Capability                             | Owner | Admin | Manager | Member | Guest | Anonymous user |
| -------------------------------------- | ----- | ----- | ------- | ------ | ----- | -------------- |
| All resources - Full access            | ✓     | ✓     | ✓       | —      | —     | —              |
| Scenario resources - Can merge         | —     | —     | —       | —      | —     | —              |
| Integration - Full access              | —     | —     | —       | —      | —     | —              |
| Integration query - Full access        | —     | —     | —       | —      | —     | —              |
| Integration schema - Full access       | —     | —     | —       | —      | —     | —              |
| Integration table - Full access        | —     | —     | —       | —      | —     | —              |
| Integration table column - Full access | —     | —     | —       | —      | —     | —              |
| Dimension - Can view                   | —     | —     | ✓       | —      | —     | —              |
| Dimension - Can create                 | —     | —     | —       | —      | —     | —              |
| Dimension - Can edit                   | —     | —     | —       | —      | —     | —              |
| Section - Can delete                   | —     | —     | —       | —      | —     | —              |
| Unlisted drivers - Full access         | —     | —     | —       | —      | —     | —              |
| Access control - Full access           | —     | —     | —       | —      | —     | —              |
| Entity anonymization - Full access     | —     | —     | —       | —      | —     | —              |
| Scenario - Full access                 | —     | —     | —       | —      | —     | —              |
| Scenario (default layer) - Can view    | —     | —     | ✓       | ✓      | —     | —              |
| Scenario - Can create                  | —     | —     | ✓       | ✓      | —     | —              |
| Integration - Can create               | —     | —     | ✓       | —      | —     | —              |
| Database column - Full access          | —     | —     | —       | —      | —     | —              |
| External driver - Full access          | —     | —     | —       | —      | —     | —              |
| Database lookups - Full access         | —     | —     | —       | —      | —     | —              |
| All resources - Can create             | —     | —     | —       | —      | —     | —              |
| Search - Full access                   | —     | —     | —       | ✓      | —     | —              |

Guest and Anonymous user have no default ACLs; they only receive access that is explicitly shared.

## Resource access levels

| Resource type    | Access level | Description                                                 |
| ---------------- | ------------ | ----------------------------------------------------------- |
| Pages            | Full access  | Can edit, delete, and share the page.                       |
| Pages            | Can edit     | Can edit page content, but not share or delete the page.    |
| Pages            | Can view     | Can view the page but can not edit or add other users.      |
| Pages            | No access    | Cannot view or access the page.                             |
| Sections         | Full access  | Can edit, delete, and share this section.                   |
| Sections         | Can view     | Can view this section and its contents.                     |
| Sections         | No access    | Cannot view this section.                                   |
| Blocks           | Full access  | Can edit, delete, and share this block.                     |
| Blocks           | Can view     | Can view this block and its contents.                       |
| Blocks           | Can drill in | Allow people to drill in to see the inputs for a given row. |
| Blocks           | No access    | Cannot view this block.                                     |
| Scenarios        | Full access  | Can edit, delete, merge, and share this scenario.           |
| Scenarios        | Can view     | Can view this scenario.                                     |
| Scenarios        | Can merge    | Allow people to merge this scenario.                        |
| Scenarios        | No access    | Cannot view this scenario.                                  |
| Database columns | Can view     | Can view this column's data.                                |
| Database columns | No access    | Cannot view this column's data.                             |

Role and resource access combine by taking the narrower result: the role sets the user's maximum workspace capability, and the resource access level controls what they can do on a specific page, section, block, scenario, or database column.

## What's next

* [Manage permissions](/guides/sharing/permissions)
* [Create share links](/guides/sharing/share-links)
* [Manage groups](/guides/sharing/groups)