Cloud IDE

A powerful, browser-based development environment purpose-built for dbt projects. No local setup, no dependency headaches. Open your browser and start building.

dbdeux Cloud IDE

Project Files

📄dim_customers.sql

📄fct_orders.sql

📄stg_payments.sql

📋schema.yml

This filedbt Core 1.10

Why a cloud IDE?

Traditional dbt development means wrestling with local Python environments, version conflicts, and inconsistent setups across your team. The dbdeux Cloud IDE eliminates all of that:

• Zero setup: No local installations. Your entire team is productive in minutes, not hours
• Consistent environments: Everyone works with the same dbt version, packages, and configurations
• Access from anywhere: Work from any device with a browser. Your project is always ready
• Real-time collaboration: See who is working on what, avoid conflicts, and share context instantly

Editor Experience

The IDE is built on the same editor engine that powers VS Code, giving you a familiar, professional editing experience:

Intelligent Code Editing

• SQL, YAML, Jinja, and Python support with full syntax highlighting
• Schema-aware autocomplete that suggests table names, column names, model refs, sources, and macros as you type
• Inline error detection that catches syntax issues before you run
• Jinja template rendering to preview compiled SQL without executing
• Multi-cursor editing for fast bulk edits across your code
• dbt snippets with full parity to the shorthand you already know from dbt Cloud: type a __ prefix and expand a full Jinja block, for example __config_table, __incremental_model, __select_ref, __docs, __env_var, __set_block, __statement, and __run_query. Snippets use tab stops so you can fill in the placeholders and move on without retyping boilerplate
• Minimap and sticky scroll toggles so you can tailor the editor to how you like to work: turn on the minimap for a birds-eye view of long files, or sticky scroll to keep the enclosing block header pinned as you scroll

Project Navigation

• File explorer with collapsible accordion sections for Project Files and Worksheets, giving a clear separation between dbt models and ad-hoc SQL. Each folder node shows a model count badge so you can see at a glance how many models live under a directory
• Drag and drop to move files within the tree, with references updated to match the new location
• Coverage lens badges on model files show whether a model has a description and how many tests it has in its schema YAML, so documentation and test gaps are visible right where you work
• Changes toggle: A toggle button with a count badge shows how many files have uncommitted modifications. Click it to switch the sidebar to the Changes view (modified files list with diff indicators) and click "Back to files" to return to the full tree. This replaces the previous Files/Changes tab pair with a lighter single-button toggle
• Quick-open (Cmd/Ctrl + P) to jump to any file instantly, with your recently opened files listed first
• Symbol search to find models, macros, and sources across your project
• Breadcrumb navigation showing your current location in the project hierarchy (wraps cleanly on narrow viewports without overlapping toolbar controls)
• Project selector in page headers: Every top-level page (Environments, Jobs, Slimmer CI, Metrics, Data Products, Audit Log) includes a project picker directly in the header. If you have no projects yet, a "New Project from Git" option lets you create one inline without navigating away

Multi-Tab Workspace

Work on multiple models simultaneously with a tabbed interface:

• Split views: Compare models side by side, reference macros while editing, or keep documentation open alongside your SQL
• Close split view with a single shortcut (Cmd/Ctrl + \)
• Worksheet tabs: Open ad-hoc SQL worksheets alongside dbt model tabs
• Project-scoped tabs: Open tabs are scoped to each project, so switching projects gives you a clean workspace without file leakage across projects
• Empty state guidance: New workspaces show helpful prompts to get you started

Custom Dialogs

All destructive actions (deleting files, discarding changes, removing connections) use in-app confirmation dialogs rather than browser popups. This provides:

• Consistent styling across all platforms
• Clear descriptions of what will happen
• Ability to show related context (e.g., affected models)

Tab Context Menu

Right-click any editor tab to access quick actions:

• Close, Close Others, Close All: Manage open tabs without hunting for the X button
• Close to the Right: Close all tabs after the current one
• Copy Path: Copy the file path to your clipboard
• Reveal in Explorer: Jump to the file in the sidebar

Worksheet tabs include additional options for renaming and duplicating.

Closing tabs in bulk (Close Others, Close All, Close to the Right) prompts you first if any of those tabs have unsaved changes, so a quick cleanup never throws away work.

Command Palette

Press Cmd/Ctrl + Shift + P to open the command palette and run any editor action by name, without hunting through menus:

• Editor text commands (format, comment, fold, and more) route straight to the underlying editor
• Jump to project-wide search, find and replace, and other IDE actions from one place
• Project TODO/FIXME finder: locate every TODO and FIXME left in your project so nothing gets forgotten

Find and Replace Across the Project

Press Cmd/Ctrl + Shift + F (or use the command palette) to search and replace across every file in the project:

• Case-sensitive, whole-word, and regular-expression matching
• Every match is previewed and grouped by file before you change anything
• Replace per file or across the whole project, with regex capture groups ($1) supported in the replacement text

Finding Things Fast

Search is surfaced everywhere you need it, so you never have to remember a shortcut to start looking:

• In-files search button: a visible control opens project-wide search directly, alongside the keyboard shortcut, so the feature is discoverable and not hidden behind a hotkey
• Search across unexpanded connections: the database search matches objects inside connections you have not expanded yet, so a table buried a few levels deep in a warehouse you have never opened still shows up in results
• Always-visible change actions: stage, unstage, and discard controls stay visible on each changed file rather than appearing only on hover, so acting on a change is a single click

Built-In Terminal

Run any dbt command directly from the integrated terminal without leaving your browser:

• dbt run, dbt test, dbt build, dbt compile
• Custom selectors and graph operators
• Full output streaming with syntax-highlighted logs

dbt Command Bar

A persistent command bar sits at the bottom of the editor so you can type and run any dbt command without breaking focus. It is built for the way you actually iterate:

dbt command bar

>Run

stg_orders model selector

stg_orders+ model selector

stg_orders+2 model selector

History · one-click rerun

dbt build --select stg_orders+12.4s↻

dbt test --select dim_customers4.1s↻

dbt run --select tag:daily31.0s↻

• Command and selector autocomplete: start typing and the bar suggests subcommands and completes model selectors straight from your project tree, so you do not have to remember exact model names
• Validation before it runs: the bar checks the command before dispatching it and tells you what is wrong (for example, a command that does not start with dbt, or a missing subcommand) instead of failing mid-run
• History recall: press the up and down arrows to walk back through commands you have already run
• One-click rerun: your per-project history keeps each command with its status and duration, so you can rerun any previous command with a single click

Quick-command chips for dbt run, dbt build, dbt test, and dbt compile are always one tap away for the common cases.

Per-File Run Button

Each open model file has its own run control directly in the editor tab header. This is a split-button scoped to the active model:

• Run (primary): Build the current model in your warehouse with a single click
• Compile: Render Jinja to SQL and display the result in the Compiled SQL tab
• Preview rows: Run and sample results
• Test: Run the model's tests
• Build: Run + test in one pass
• View Compiled SQL: Jump straight to the compiled output for the active model, compiling it first if needed. The compiled artifact is revealed in the last-run output tree so you can open it directly
• Show in DAG: Open the lineage graph focused on the active model, so you can see its neighbors without leaving the editor
• Preview: Run the model's compiled SQL as a row-limited, read-only query and see sample rows instantly. When no compiled artifact exists yet, dbdeux falls back to a dbt show style preview

All operations are automatically scoped to the active file. No need to select the model first.

Interactive runs execute against your current working changes, including edits you have not committed yet. You can iterate on a model and run it immediately, without a commit-and-push cycle just to test an idea.

File Tree Actions

Right-click any file or model in the project tree for context actions that save round-trips to the editor:

• Copy name, Copy path, and Copy as ref ({{ ref('model_name') }}) so you can paste a reference without typing it by hand
• Select * from model: open a scratch query that selects from the model through ref(), ready to run
• Duplicate, Rename, and the usual file operations

The editor also completes references as you type: model and seed names autocomplete inside ref('...'), and source names autocomplete inside source('...'), both fed live from your project tree and your YAML source definitions. dbt-aware icons in the tree make models, seeds, tests, and configs easy to tell apart at a glance.

Run Toolbar

The global run toolbar is a unified split-button at the top of the editor for project-wide operations:

• Primary button: Click to run the selected operation immediately
• Caret menu: Opens a panel with all run options in one place

Operations

Action	What it does
Run	Builds the selected model in your warehouse
Test	Runs associated tests and shows pass/fail results
Build	Runs the model then executes its tests
Compile	Shows the compiled SQL without executing anything

Scope Control

Choose what models to include without writing --select flags manually:

• This file: Only the current model
• +downstream: Current model plus everything that depends on it
• Everything: Full project build
• Custom: Write your own selector expression

The toolbar shows a live command preview so you see exactly what will execute.

Impact Preview

Before you run, an impact preview resolves your current selector and tells you how many nodes will run and why each one is selected. Instead of guessing what state:modified+ or a custom selector expands to, you see the node count and the reason each model is included (changed, downstream of a change, and so on), so a build never runs across far more of your project than you intended.

Changed Models Only

Toggle Changed models only in the run options to run only the models you have modified since the last production build. This uses dbt's state:modified+ selector with deferred state from the production manifest, so unchanged models are skipped entirely. Combined with the scope selector, this is the fastest way to iterate on just what you are working on.

Production Run Guardrail

When the active connection is tagged as production (e.g., prod, production, live), or when you select the project's designated Production environment, write operations (run, build, seed, snapshot) show a confirmation dialog before executing. The dialog names the environment or connection and the exact command you are about to run. Read-only commands (compile, list, show) are not gated. This prevents accidental materializations in production warehouses from the IDE.

If you launch a production run from a branch other than the one your production environment tracks, the dialog adds a wrong-branch warning, so you never ship a feature branch's models to production by mistake.

Defer to Production

Turn on Defer to production in the run options to resolve ref() and source() against the last production build for any models you have not changed. You get the speed of building only your changed models while everything they depend on still points at trusted production data. Your selection is unchanged; only unbuilt upstream models are deferred.

dbt Version Selector

Pick which dbt engine version to use for the run:

• Core 1.8 (default)
• Core 1.10
• Fusion (preview)

The version is remembered per project. A footer note shows which version the last run used for confirmation.

Results appear inline with row counts, duration, and any errors highlighted for quick debugging.

Connection Indicator

The header toolbar shows a live connection indicator in the top-right corner:

• Green dot with the connection name, database, and schema when a warehouse connection is active
• Gray dot with "No connection" when no connection is selected
• Warehouse icon showing the adapter brand (Snowflake, BigQuery, MotherDuck, Microsoft Fabric, etc.) on narrow viewports
• Tag chips from the connection's tags appear on the status bar, so you can see at a glance whether you are connected to a production or dev environment
• When a dbt model file is focused, the connection indicator is dimmed because dbt models run against the selected profile and environment, not an ad-hoc connection. The indicator is only active when a worksheet (ad-hoc SQL) is focused

This makes it immediately clear which warehouse your queries are running against, and prevents confusion between dbt environment connections and ad-hoc worksheet connections.

Colorized Run Output

The Output panel colorizes dbt log lines for quick scanning:

• Green for success messages and passing tests
• Red for errors and failures
• Yellow for warnings
• Gray for debug and informational lines
• A Success badge appears at the top when a run completes without errors
• An HH:MM:SS timestamp on every log line so you can see exactly when each step ran and how long stages took

This makes it easy to spot issues at a glance without reading every line.

The output log persists as you move around the editor, so switching files, panels, or sections never wipes the results of a run you are still reading. From the History panel you can reopen the log of any past run with View log, so a build you ran an hour ago is still one click away instead of gone the moment you looked elsewhere.

Last Run Artifacts

The file explorer includes a read-only browser for the artifacts produced by your most recent run (dbt's target/ output). It loads on demand, so it never slows down the editor, and lets you inspect compiled SQL, the run manifest, and other generated files without digging through a terminal or re-running anything.

Keyboard Shortcuts

Power users will feel at home with familiar shortcuts:

Shortcut	Action
Cmd/Ctrl + Enter	Run current model
Cmd/Ctrl + S	Save file
Cmd/Ctrl + P	Quick-open file
Cmd/Ctrl + Shift + P	Command palette
Cmd/Ctrl + /	Toggle line comment
Cmd/Ctrl + D	Select next occurrence
Cmd/Ctrl + Shift + F	Search across project

Compiled SQL Tab

The bottom panel includes a dedicated Compiled SQL tab that shows the rendered output from your most recent compile, run, or build:

• Automatic capture: Every time dbt compiles a model, the rendered SQL appears in this tab
• Multi-model selector: When a build touches multiple models, click tabs to switch between their compiled output
• One-click copy: Copy the compiled SQL to your clipboard for manual execution or debugging
• Live streaming: While a compile/run is in progress, the tab shows a spinner and populates results as they arrive
• Command context: A label shows which dbt command produced the output (e.g., "compiled via dbt run")

This replaces the need to dig through log output to find your compiled SQL.

Local Compiled SQL Preview

Click Local Preview on a model to see its compiled SQL instantly, rendered in your browser from your current working files, with no warehouse round-trip and no waiting on a compile job. Because it reads your open editor buffers, unsaved edits are included, so you can tweak a ref() or a {{ var() }} and watch the compiled output update immediately.

Local Preview is clearly labeled as a fast approximation, and it is honest about its limits:

• Eligibility check first: before rendering, dbdeux checks whether the model uses constructs the browser cannot resolve trustworthily (for example warehouse introspection, statement blocks, incremental or snapshot runtime state, or custom relation-naming macros). If it does, the preview panel explains exactly why in plain language
• One-click authoritative fallback: when a model is not eligible, or whenever you want the real thing, a single click runs an authoritative dbt compile on the compute layer and shows that result instead
• Diagnostics: the panel lists any constructs that forced a fallback and the model's resolved dependencies, so nothing is hidden
• Secret-safe: secret environment variables never enter the local render path. A model that depends on one automatically falls back to authoritative compile

Adapter-aware relation names mean the preview matches how names resolve for your warehouse (Snowflake, BigQuery, Postgres, Redshift, Databricks, and DuckDB). When custom naming macros make names impossible to derive locally, the preview falls back to the last build's artifact names so what you see still lines up with reality.

Format Document

Right-click in the editor and choose Format Document (or use your standard format shortcut) to tidy up SQL and YAML files:

• SQL: Reformats the query for consistent indentation and keyword casing. dbt files stay safe because Jinja expressions, statements, and comments ({{ ... }}, {% ... %}, {# ... #}) are preserved exactly as written
• YAML: Reformats schema.yml and other YAML files while keeping your comments and anchors intact

If a file cannot be parsed, dbdeux leaves it untouched rather than risk mangling your content.

User Preferences

Access the preferences panel from the user menu (avatar in the top-right corner). Settings are saved to your browser and apply immediately across the entire app:

Setting	What it controls
Theme	Switch between light and dark mode (also available from the user menu toggle)
Show all project folders	When on, the file explorer sidebar shows folders from every project in the workspace. When off (default), only the active project's files appear
Default landing workspace	Choose which workspace opens by default when you sign in, so you always start in the one you use most

Preferences persist across sessions via local storage. Theme changes sync with the system theme preference if supported by your browser.

Layout Persistence and Caching

The editor remembers your workspace layout across sessions:

• Bottom panel height (Output, Compiled SQL) is preserved
• Your last-used project selection persists so you start where you left off
• The onboarding checklist only appears for first-time users and stays dismissed for returning users
• User preferences (theme, file explorer scope) are saved per browser
• Server reads are cached through an app-wide query cache, so switching between tabs you have already visited is instant with no network round-trip

Git Integration

Version control is built directly into the IDE. No need for a separate Git client:

• Branch management: Create, switch, and merge branches
• Visual diff: See exactly what changed before committing
• Commit and push: Stage files, write commit messages, and push to remote
• Pull updates: Stay in sync with your team's latest changes
• Conflict resolution: Visual merge conflict resolution when branches diverge

→ Learn more in Version Control & Collaboration

How It Compares

Capability	dbdeux Cloud IDE	dbt Cloud IDE	Local VS Code + dbt
Setup time	Zero - open browser, start coding	Minimal - browser-based but limited editor features	Hours of Python env, adapter, and extension setup
Split views	Side-by-side model editing with shortcut toggle	Not available	Native VS Code split
Run scoping	Per-file run button with scope selector (run/compile/test/build)	Global run only	CLI commands per terminal
Compiled SQL	Dedicated tab with multi-model selector and live streaming	Inline in logs	CLI output only
Instant preview	Local in-browser compiled SQL from unsaved edits, with one-click authoritative fallback	Requires a compile run	Requires a CLI compile
Git integration	Built-in branch, commit, push, PR creation, and conflict resolution	Basic Git support	Full Git via terminal
Schema autocomplete	Warehouse-aware suggestions for tables, columns, refs, macros	Limited autocomplete	Requires extensions
DAG panel	Collapsible lineage panel built into the editor with minimize-to-rail	Separate lineage page	Separate tooling
Layout persistence	Panel heights, project selection, and onboarding state remembered	Limited	User manages settings