# Migrating dbt™ jobs from Github Actions to Paradime Bolt

## Overview

This guide walks you through migrating your dbt™ jobs from GitHub Actions to Paradime's Bolt orchestration platform. Paradime offers a purpose-built solution for dbt™ orchestration with features like deferred runs, smart scheduling, and integrated monitoring.

***

## Part 1: Understanding Your Current GitHub Actions Setup

#### Example GitHub Actions Workflow

Here's a typical GitHub Actions workflow for running dbt™ jobs:

```yaml
# .github/workflows/dbt_production.yml
name: dbt Production Run

on:
  schedule:
    # Run daily at 6 AM UTC
    - cron: '0 6 * * *'
  workflow_dispatch:  # Allow manual triggers
  push:
    branches:
      - main

jobs:
  dbt_run:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install dbt
        run: |
          pip install dbt-core dbt-snowflake==1.7.0

      - name: Install dependencies
        run: |
          dbt deps
        env:
          DBT_PROFILES_DIR: .

      - name: Run dbt seed
        run: dbt seed --target prod
        env:
          DBT_SNOWFLAKE_ACCOUNT: ${{ secrets.SNOWFLAKE_ACCOUNT }}
          DBT_SNOWFLAKE_USER: ${{ secrets.SNOWFLAKE_USER }}
          DBT_SNOWFLAKE_PASSWORD: ${{ secrets.SNOWFLAKE_PASSWORD }}
          DBT_SNOWFLAKE_ROLE: ${{ secrets.SNOWFLAKE_ROLE }}
          DBT_SNOWFLAKE_WAREHOUSE: ${{ secrets.SNOWFLAKE_WAREHOUSE }}
          DBT_SNOWFLAKE_DATABASE: ${{ secrets.SNOWFLAKE_DATABASE }}
          DBT_PROFILES_DIR: .

      - name: Run dbt models
        run: dbt run --target prod
        env:
          DBT_SNOWFLAKE_ACCOUNT: ${{ secrets.SNOWFLAKE_ACCOUNT }}
          DBT_SNOWFLAKE_USER: ${{ secrets.SNOWFLAKE_USER }}
          DBT_SNOWFLAKE_PASSWORD: ${{ secrets.SNOWFLAKE_PASSWORD }}
          DBT_SNOWFLAKE_ROLE: ${{ secrets.SNOWFLAKE_ROLE }}
          DBT_SNOWFLAKE_WAREHOUSE: ${{ secrets.SNOWFLAKE_WAREHOUSE }}
          DBT_SNOWFLAKE_DATABASE: ${{ secrets.SNOWFLAKE_DATABASE }}
          DBT_PROFILES_DIR: .

      - name: Run dbt tests
        run: dbt test --target prod
        env:
          DBT_SNOWFLAKE_ACCOUNT: ${{ secrets.SNOWFLAKE_ACCOUNT }}
          DBT_SNOWFLAKE_USER: ${{ secrets.SNOWFLAKE_USER }}
          DBT_SNOWFLAKE_PASSWORD: ${{ secrets.SNOWFLAKE_PASSWORD }}
          DBT_SNOWFLAKE_ROLE: ${{ secrets.SNOWFLAKE_ROLE }}
          DBT_SNOWFLAKE_WAREHOUSE: ${{ secrets.SNOWFLAKE_WAREHOUSE }}
          DBT_SNOWFLAKE_DATABASE: ${{ secrets.SNOWFLAKE_DATABASE }}
          DBT_PROFILES_DIR: .

      - name: Notify on failure
        if: failure()
        run: echo "Job failed - send notification"

```

#### What This Workflow Does

1. **Triggers** on a daily schedule, manual dispatch, or push to main
2. **Installs** dbt™ and dependencies
3. **Runs** dbt™ seed, run, and test commands
4. **Uses** GitHub Secrets for warehouse credentials
5. **Notifies** on failure (basic)

***

## Part 2: Prerequisites for Paradime Migration

Before migrating, ensure you have:

#### 1. Paradime Workspace Setup

* Active Paradime account
* Workspace created and configured
* Access to the Bolt application

#### 2. Data Warehouse Connection

* Production connection configured in Paradime
* This connection should have the same permissions as your GitHub Actions credentials
* Navigate to: **Settings → Connections** to set this up

#### 3. Git Repository Connected

* Your dbt™ project repository connected to Paradime
* Git credentials configured
* Navigate to: **Settings → Git Integration**

#### 4. GitHub App Integration (for Native CI/CD)

* **Paradime GitHub App installed** in your GitHub organization
* This enables native Turbo CI and Continuous Deployment without manual GitHub Actions
* **Installation Guide**: [docs.paradime.io/app-help/documentation/integrations/ci-cd/github](https://docs.paradime.io/app-help/documentation/integrations/ci-cd/github)

#### 5. dbt™ Project

* Your dbt™ project accessible in Paradime IDE
* Models materialized and tested in development

***

## Part 3: Creating Your First Paradime Schedule

### Method 1: Using the Bolt UI (Recommended for Beginners)

#### Step 1: Access Bolt

1. Log into your Paradime workspace
2. Navigate to **Bolt** from the left sidebar
3. Click **Create Schedule**

#### Step 2: Configure Schedule Settings

Fill in the basic settings:

* **Type**: Choose **Standard** (equivalent to a basic GitHub Actions job)
* **Name**: `daily_production_run` (descriptive name for your schedule)
* **Git Branch**: `main` (or your production branch)
* **Owner Email**: Your email address

#### Step 3: Add Commands

Add your dbt™ commands in sequence (equivalent to the steps in your GitHub Action):

```
dbt seed --target prod
dbt run --target prod
dbt test --target prod

```

{% hint style="success" %}
**Pro Tip**: Each command runs sequentially. If one fails, subsequent commands won't execute.
{% endhint %}

#### Step 4: Configure Trigger

Select your trigger type:

* **Scheduled Run**: For time-based execution (like cron)
  * Choose **Cron Schedule**: `0 6 * * *` (daily at 6 AM UTC)
  * Or use presets like `@daily`, `@hourly`, `@weekly`
* **On Merge**: Trigger when PR is merged to specified branch
* **On Run Completion**: Chain jobs together

#### Step 5: Set Up Notifications

Configure alerts to know when jobs succeed or fail:

* **Slack Notifications**:
  * Toggle **Slack Notify On**: Select `failed` and/or `passed`
  * Enter channel: `#data-team-alerts`
* **Email Notifications**:
  * Toggle **Email Notify On**: Select `failed` and/or `passed`
  * Enter email addresses

#### Step 6: Deploy

Click **Create Schedule** to deploy your job.

***

### Method 2: Using Schedules as Code (YAML)

For teams that prefer infrastructure-as-code, Paradime supports YAML-based schedules.

#### Step 1: Create `paradime_schedules.yml`

In your dbt™ project root, create or edit `paradime_schedules.yml`:

```yaml
# paradime_schedules.yml
- name: daily_production_run
  schedule: "0 6 * * *"  # Daily at 6 AM UTC
  environment: production
  git_branch: main
  commands:
    - dbt seed --target prod
    - dbt run --target prod
    - dbt test --target prod
  slack_on:
    - failed
    - passed
  slack_notify:
    - "#data-team-alerts"
  email_on:
    - failed
  email_notify:
    - "data-team@company.com"

```

#### Step 2: Commit and Push

```bash
git add paradime_schedules.yml
git commit -m "Add production schedule"
git push

```

#### Step 3: Sync in Paradime

Paradime will automatically detect and sync your schedule configuration.

***

## Part 4: Migration Mapping Guide

Here's how GitHub Actions concepts map to Paradime Bolt:

| GitHub Actions           | Paradime Bolt             | Notes                         |
| ------------------------ | ------------------------- | ----------------------------- |
| `on.schedule.cron`       | Cron Schedule trigger     | Same cron syntax              |
| `on.push.branches`       | On Merge trigger          | Triggers on merge to branch   |
| `on.workflow_dispatch`   | Manual run button         | Available in Bolt UI          |
| `jobs.steps`             | Commands list             | Sequential execution          |
| `env` secrets            | Connection credentials    | Managed in Paradime settings  |
| Notifications            | Slack/Email notifications | Built into Bolt               |
| `runs-on`                | Paradime environment      | Managed infrastructure        |
| `uses: actions/checkout` | Automatic                 | Paradime handles git checkout |

***

## Part 5: Advanced Features in Paradime

#### Native GitHub Integration Benefits

**With the Paradime GitHub App installed, you get:**

* **Automatic PR checks**: Turbo CI runs automatically on every pull request
* **Merge triggers**: Deploy changes instantly when PRs are merged
* **Lineage Diff comments**: Automated comments showing downstream impact on Looker, Tableau, ThoughtSpot, and dbt™ mesh
* **No GitHub Actions needed**: Paradime handles triggering and status reporting
* **Centralized logs**: All CI/CD runs visible in Bolt dashboard

**Installation**: Follow the guide at [docs.paradime.io/app-help/documentation/integrations/ci-cd/github](https://docs.paradime.io/app-help/documentation/integrations/ci-cd/github)

***

### Deferred Runs (Optimization)

Paradime offers **Deferred Schedules** that only run changed models:

```yaml
- name: incremental_run
  schedule: "@hourly"
  environment: production
  git_branch: main
  deferred_schedule:
    enabled: true
    deferred_schedule_name: daily_production_run
    successful_run_only: true
  commands:
    - dbt run -s state:modified+ --target prod
    - dbt test -s state:modified+ --target prod

```

**Benefits**:

* Faster execution (only modified models)
* Lower compute costs
* Smart state comparison

### Turbo CI for Pull Requests

**🎉 Paradime supports native GitHub integration for Turbo CI!** No need to write GitHub Actions workflows manually.

#### Option 1: Native GitHub App Integration (Recommended)

The easiest way to enable Turbo CI is through Paradime's native GitHub app, which automatically triggers CI checks when you open a pull request.

**Setup Steps:**

1. **Install the Paradime GitHub App**:
   * Navigate to **Settings > Integrations** in Paradime
   * Click **Connect** next to GitHub Integration
   * Follow the authentication flow and select your repositories
   * Click **Install and authorize**
   * Complete the user-level OAuth by going to **Profile > Profile Settings**
2. **Create a Turbo CI Schedule in Bolt**:

   ```yaml
   - name: turbo_ci_run
     schedule: "OFF"  # Only runs on PR
     environment: development
     git_branch: main
     deferred_schedule:
       enabled: true
       deferred_schedule_name: daily_production_run
     commands:
       - dbt build -s state:modified+ --target ci
     slack_on:
       - failed
     slack_notify:
       - "#dev-team"

   ```
3. **That's it!** When you open a pull request, Paradime will automatically:
   * Trigger the Turbo CI schedule
   * Build modified models in a temporary schema (`paradime_turbo_ci_pr_<commit_sha>`)
   * Run tests on changed models
   * Post status checks directly to your PR

**📚 Documentation**: [GitHub Integration Setup](https://docs.paradime.io/app-help/documentation/integrations/ci-cd/github) | [Turbo CI Guide](https://docs.paradime.io/app-help/documentation/bolt/ci-cd/turbo-ci)

#### Option 2: Manual GitHub Actions (Alternative)

If you prefer to manage your own GitHub Actions workflow or need custom logic:

```yaml
# .github/workflows/paradime_turbo_ci.yml
name: Paradime Turbo CI

on:
  pull_request:
    branches: [main]

jobs:
  turbo_ci:
    runs-on: ubuntu-latest
    steps:
      - name: Run Paradime Turbo CI
        run: |
          pip install paradime-io
          paradime bolt run "turbo_ci_run" --branch ${{ github.sha }} --wait
        env:
          PARADIME_API_KEY: ${{ secrets.PARADIME_API_KEY }}
          PARADIME_API_SECRET: ${{ secrets.PARADIME_API_SECRET }}
          PARADIME_API_ENDPOINT: ${{ secrets.PARADIME_API_ENDPOINT }}

```

### Continuous Deployment on Merge

**🎉 Paradime supports native GitHub integration for Continuous Deployment!** Automatically deploy when PRs are merged.

#### Option 1: Native GitHub App Integration (Recommended)

With the Paradime GitHub app installed (see Turbo CI setup above), you can enable automatic deployments on merge without any GitHub Actions configuration.

**Setup in Bolt UI:**

1. Create or edit a schedule in Bolt
2. Set **Schedule Type** to **Deferred**
3. Enable **Trigger on Merge**
4. Select your production branch (e.g., `main`)
5. Configure your commands:

**Or via YAML:**

```yaml
- name: continuous_deployment
  schedule: "OFF"
  environment: production
  git_branch: main
  trigger_on_merge: true
  deferred_schedule:
    enabled: true
    deferred_schedule_name: daily_production_run
    successful_run_only: true
  commands:
    - dbt run -s state:modified+ --target prod
    - dbt test -s state:modified+ --target prod
  slack_on:
    - failed
    - passed
  slack_notify:
    - "#deployment-alerts"

```

**How it works:**

* When a PR is merged to your production branch, Paradime automatically triggers the schedule
* Only modified models are deployed (using state comparison)
* Status updates are posted to Slack
* No GitHub Actions workflow needed!

**📚 Documentation**: [GitHub Native CD Guide](https://docs.paradime.io/app-help/documentation/bolt/ci-cd/continuous-deployment-with-bolt/continuous-deployment)

#### Option 2: Manual GitHub Actions (Alternative)

If you need custom deployment logic or prefer managing workflows yourself:

```yaml
# .github/workflows/paradime_cd.yml
name: Paradime Continuous Deployment

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to Production
        run: |
          pip install paradime-io
          paradime bolt run "continuous_deployment" --wait
        env:
          PARADIME_API_KEY: ${{ secrets.PARADIME_API_KEY }}
          PARADIME_API_SECRET: ${{ secrets.PARADIME_API_SECRET }}
          PARADIME_API_ENDPOINT: ${{ secrets.PARADIME_API_ENDPOINT }}

```

***

## Part 6: Step-by-Step Migration Process

#### Phase 1: Parallel Run (Week 1)

1. **Keep GitHub Actions running** as-is
2. **Create equivalent schedules** in Paradime Bolt
3. **Monitor both** for consistency
4. **Compare results** and timing

#### Phase 2: Validation (Week 2)

1. **Verify all jobs** run successfully in Paradime
2. **Test notifications** (Slack/email)
3. **Check monitoring** and logs
4. **Validate data quality** remains consistent

#### Phase 3: Cutover (Week 3)

1. **Disable GitHub Actions** schedules (comment out cron)
2. **Keep GitHub Actions files** for emergency fallback
3. **Monitor Paradime** closely for first few days
4. **Update documentation** and runbooks

#### Phase 4: Cleanup (Week 4+)

1. **Archive GitHub Actions** workflows
2. **Update team documentation**
3. **Train team** on Bolt interface
4. **Optimize schedules** using deferred runs

***

## Part 7: Troubleshooting Common Issues

#### Issue 1: Schedule Not Running

**Check**:

* Schedule is not paused (look for pause icon)
* Cron syntax is correct
* Branch exists and is accessible
* Production connection is active

#### Issue 2: Commands Failing

**Check**:

* Connection credentials are valid
* Target profile exists in `profiles.yml`
* Models exist in specified branch
* Check logs in Bolt → Run History

#### Issue 3: Notifications Not Sending

**Check**:

* Slack workspace is connected (Settings → Integrations)
* Channel names are correct (include `#`)
* Email addresses are valid
* Notification toggles are enabled

#### Issue 4: Git Sync Issues

**Check**:

* Git credentials are valid
* Branch exists
* Repository is accessible
* Try manual sync in Settings

***

## Part 8: Best Practices

#### 1. Naming Conventions

Use descriptive, consistent names:

* ✅ `daily_full_refresh`
* ✅ `hourly_incremental_models`
* ❌ `schedule1`
* ❌ `test`

#### 2. Start Simple

Begin with **Standard schedules**, then adopt:

* Deferred runs for optimization
* Turbo CI for PR validation
* On Run Completion for dependencies

#### 3. Monitor Proactively

* Set up Slack notifications for all production jobs
* Review Run History weekly
* Check SLA compliance in analytics

#### 4. Use Version Control

* Keep `paradime_schedules.yml` in git
* Review changes in PRs
* Document major changes

#### 5. Leverage Deferred Runs

After establishing baseline schedules:

* Identify frequently-modified models
* Create deferred schedules for efficiency
* Monitor compute savings

***

## Part 9: Quick Reference

#### Common Cron Schedules

```
@hourly          # Every hour at minute 0
@daily           # Every day at midnight UTC
@weekly          # Every Sunday at midnight UTC
0 6 * * *        # Daily at 6 AM UTC
0 */4 * * *      # Every 4 hours
0 9 * * 1-5      # Weekdays at 9 AM UTC

```

#### Essential Commands

```bash
# Run all models
dbt run

# Run specific model
dbt run -s my_model

# Run modified models only
dbt run -s state:modified+

# Test all models
dbt test

# Full refresh
dbt run --full-refresh
```

#### Useful Links

* [Paradime Documentation](https://docs.paradime.io/)
* [Bolt Schedules Guide](https://docs.paradime.io/app-help/documentation/bolt)
* [Schedule Types Overview](https://docs.paradime.io/app-help/guides/paradime-101/running-dbt-in-production-with-bolt/understanding-schedule-types-and-triggers)

***

## Conclusion

Migrating from GitHub Actions to Paradime Bolt offers:

* **Simplified management**: No infrastructure to maintain
* **Better observability**: Built-in monitoring and analytics
* **Cost optimization**: Deferred runs and smart scheduling
* **Native dbt™ integration**: Purpose-built for dbt™ workflows
* **Team collaboration**: Centralized scheduling and monitoring

Start with a simple schedule migration, validate in parallel, then gradually adopt advanced features like deferred runs and Turbo CI for maximum efficiency.

***

**Questions or Issues?**

* Check the [Paradime Help Center](https://support.claude.com/)
* Review the [Bolt Documentation](https://docs.paradime.io/app-help/documentation/bolt)
* Contact Paradime support for assistance


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.paradime.io/app-help/guides/migrating-dbt-tm-jobs-from-github-actions-to-paradime-bolt.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.