How to Build an Automated Resume Screening Pipeline with Paradime and OpenClaw

Stop wasting hours copy-pasting candidate data between Gmail, spreadsheets, and scoring rubrics. If you've ever set up a local Python environment just to automate a hiring workflow—only to fight with credential files, cron daemons, and broken pip installs—you already know the pain.

This guide walks you through building a fully automated resume screening pipeline that scans your Gmail inbox for job applications, extracts resume content, scores candidates against your criteria using OpenClaw's AI agent capabilities, and updates a Google Sheets tracker—all orchestrated on a daily cron schedule through Paradime's Bolt scheduler. No local config hell. No "it works on my machine." Just a clean, UI-driven production pipeline.

Target keyword: paradime openclaw resume screening

What Is Paradime?

Paradime is an all-in-one AI platform that replaces dbt Cloud™. It gives analytics and data teams a single workspace to code, ship, fix, and scale data pipelines for analytics and AI—built on top of dbt Core™.

Here's what matters for this guide:

• Code IDE — An AI-native development environment that cuts dbt™ and Python development time by 83%+. You write and test your scripts here.

• Bolt Scheduler — A production-grade orchestrator that runs dbt™ commands and Python scripts on a schedule. Configure cron expressions, set environment variables, and monitor runs—all from the UI.

• Environment Variables — Securely store API keys and credentials at the workspace level or per-schedule. No .env files committed to Git.

• DinoAI Debugging — When a run fails, DinoAI generates AI-powered summaries of what went wrong and suggests fixes.

Think of Paradime as your production control plane for data workflows. You write the logic; Bolt runs it reliably; Radar monitors cost. That's the whole story.

For more, see the Paradime docs.

What Is OpenClaw?

OpenClaw (formerly Clawdbot, then Moltbot) is an open-source, locally-hosted AI agent platform that can autonomously execute tasks across your machine and messaging apps. Unlike a simple chatbot, OpenClaw acts—it reads emails, manages calendars, organizes files, and runs commands.

Key characteristics:

• Privacy-first architecture — Runs entirely on your local machine. Data never leaves your hardware except when sent to the LLM API you configure.

• Extensible skills system — Over 3,000+ community-built skills in the public registry, including Google Workspace Automation for Gmail, Sheets, Drive, and Calendar.

• Multi-provider LLM support — Works with Anthropic, OpenAI, Google, OpenRouter, and more.

• SDK and CLI — Install via curl -fsSL https://openclaw.ai/install.sh | bash and manage everything from the command line or browser dashboard.

For this pipeline, we're using OpenClaw's AI capabilities to parse and score resume content against job criteria—the kind of nuanced text analysis that pure regex and keyword matching can't handle.

Architecture Overview

Before diving into setup, let's visualize the end-to-end flow:

Figure 1: End-to-end resume screening pipeline — Gmail → Python script → OpenClaw scoring → Google Sheets tracker, all orchestrated by Paradime Bolt.

Setup: OpenClaw SDK + Gmail API + Google Sheets API

Step 1: Install OpenClaw

OpenClaw requires Node.js 22+ (Node 24 recommended). Install the CLI:

Run the onboarding wizard:

Verify the gateway is running:

Step 2: Configure OpenClaw with Your LLM Provider

OpenClaw needs an LLM provider API key to perform the resume scoring. Configure it in ~/.openclaw/openclaw.json:

Or set it as an environment variable:

Opinion: Use Anthropic's Claude or OpenAI's GPT for resume scoring. These models handle nuanced evaluation (e.g., "Does this candidate's 3 years of React experience match our need for frontend leadership?") far better than smaller models.

Step 3: Install the Google Workspace Automation Skill

OpenClaw's skill ecosystem includes a dedicated Google Workspace skill:

This skill handles Gmail, Drive, Sheets, and Calendar integrations with scope-aware OAuth planning.

Step 4: Set Up Google Cloud Credentials

You need OAuth credentials for both the Gmail API and Google Sheets API:

1. Go to Google Cloud Console → Create a new project (e.g., resume-screening-pipeline)

2. Enable Gmail API and Google Sheets API under APIs & Services → Library

3. Configure OAuth consent screen → External → Fill in app name and contact email

4. Add OAuth scopes:

5. Create OAuth credentials → Desktop app → Download the JSON file

Save the credentials:

Step 5: Authorize Your Google Account

In the OpenClaw dashboard, connect to Google via /connect google. This opens a browser window for OAuth sign-in and stores tokens locally.

Verify:

Figure 2: Google API credential setup flow — from Cloud Console to verified OpenClaw connection.

The Script: Scan, Extract, Score, Update

Here's the core Python script that ties everything together. This script is designed to run as a Paradime Bolt Python script in production.

Project Structure

pyproject.toml (Dependency Management)

Paradime uses Poetry for dependency management. Your first Bolt command must be poetry install.

scripts/resume_screener.py

This is a single script, but every section maps to a clear responsibility: scan → extract → score → update.

Environment Variables: GOOGLE_CREDENTIALS_JSON and OPENCLAW_API_KEY

Here's where Paradime eliminates the local config pain. Instead of juggling .env files, credential JSON files in gitignored directories, or (worse) hardcoded secrets, you configure everything through the Paradime UI.

Setting Up Env Vars in Paradime

1. Navigate to Settings → Workspaces → Environment Variables

2. In the Bolt Schedules section, click Add New

3. Add the following variables:

1. Click the Save icon

These variables are only available in Bolt schedules (production jobs)—they never leak into your development environment.

Why this matters: Every time you store a credentials.json file locally, you're one accidental git add . away from a security incident. Paradime's env var system keeps secrets out of your repo and scoped to production only. See the docs.

Your Python script accesses them cleanly:

Figure 3: Environment variable scoping in Paradime — global defaults with per-schedule overrides, all managed from the UI.

Bulk Upload (Optional)

For teams managing many variables, Paradime supports CSV bulk upload:

Upload via Settings → Environment Variables → Bulk Upload.

Bolt Schedule: Cron Daily

Now wire the script into a daily Bolt schedule.

Creating the Schedule

1. Navigate to Bolt from the Paradime home screen

2. Click + New Schedule → + Create New Schedule

3. Configure the schedule:

1. Click Save

Important: The first command must be poetry install to set up the virtual environment and install dependencies. This is how Paradime handles Python dependency management.

Why 0 8 * * *?

This runs at 8 AM UTC every day—right before your hiring team starts their morning review. Adjust to match your timezone. Paradime supports timezone configuration in the Bolt UI, and you can use crontab.guru to validate expressions.

Figure 4: Daily execution flow — Bolt triggers the script, which scans Gmail, scores via OpenClaw, and updates the Sheets tracker.

Monitoring and Debugging

Once your schedule is live, Paradime gives you three layers of observability.

Viewing Run History

Navigate to Bolt → your schedule name to see the run history dashboard:

• Status — Success or Error at a glance

• Trigger — Manual or Automatic (cron)

• Duration — How long the run took

• Branch and Commit — Which code version executed

Log Types

Click any run to access three log levels:

1. Summary Logs — DinoAI-generated overview. If your script fails because GOOGLE_CREDENTIALS_JSON isn't set, DinoAI will tell you exactly that and suggest checking your environment variables. This is the "read this first" log.

2. Console Logs — Detailed chronological output. Every print() statement from your script shows up here. Use the "jump to" feature to locate errors quickly.

3. Debug Logs — System-level details for deep troubleshooting. Useful when you need to verify that Poetry installed the right package versions or that the correct Python runtime was used.

Setting Up Notifications

Don't wait for someone to check the Bolt UI. Set up alerts:

• Slack notifications — Configure in schedule settings under Slack Notify On → failed. Point to your #hiring-pipeline-alerts channel.

• Email notifications — Add the hiring manager's email under Email Notify On → failed.

See Setting Up Notifications for details.

Figure 5: Monitoring and debugging workflow — DinoAI surfaces failures, Slack alerts notify the team, and three log levels help you drill down.

Troubleshooting Common Issues

Here are the issues you'll most likely hit, and how to fix them fast.

❌ PARA-1000: Missing production warehouse connection

Cause: Bolt needs a production warehouse connection even for Python-only scripts.

Fix: Go to Account Settings → Connections, add a production warehouse connection, and ensure it's active. See Paradime error list.

❌ KeyError: 'GOOGLE_CREDENTIALS_JSON'

Cause: Environment variable isn't set in the Bolt schedule scope.

Fix: Navigate to Settings → Workspaces → Environment Variables → Bolt Schedules and verify the variable exists. If you've set it globally but the schedule has an override, check the schedule-level override too.

❌ ConnectionRefusedError when calling OpenClaw

Cause: The OpenClaw gateway isn't running on the machine executing the Bolt schedule.

Fix: For production, you need OpenClaw running as a persistent service or use a cloud-hosted LLM API directly instead of the local gateway. Modify the score_resume() function to call OpenAI or Anthropic APIs directly:

❌ Gmail API returns empty results

Cause: The Gmail query doesn't match any emails, or the service account doesn't have domain-wide delegation.

Fix:

• Test your query directly in Gmail's search bar first: subject:application has:attachment newer_than:1d

• If using a service account, enable domain-wide delegation in Google Admin Console

• Adjust the newer_than parameter if running less frequently

❌ Google Sheets API 403 Forbidden

Cause: The service account doesn't have edit access to the spreadsheet.

Fix: Share the Google Sheet with the service account email (e.g., your-service@project.iam.gserviceaccount.com) as an Editor.

❌ poetry install fails in Bolt

Cause: pyproject.toml has dependency conflicts or isn't in the repository root.

Fix:

• Ensure pyproject.toml is committed to your main branch

• Run poetry lock locally and commit the poetry.lock file

• Check that Python version constraints in pyproject.toml match Paradime's runtime

❌ OpenClaw returns malformed JSON from resume scoring

Cause: The LLM sometimes wraps JSON in markdown code blocks or adds commentary.

Fix: Add a JSON extraction fallback:

Wrapping Up

Let's recap what you've built:

Figure 6: Complete pipeline architecture — scan, score, update, monitor. All automated, all observable.

Here's what you walked away with:

1. A production Python script that scans Gmail for applications, extracts resume content from PDFs and email bodies, and scores them using OpenClaw's AI.

2. Secure credential management through Paradime's UI-driven environment variables—no .env files, no local credential JSONs in your repo.

3. Automated daily execution via Bolt's cron scheduler (0 8 * * *), with Poetry-managed dependencies.

4. Observable, debuggable runs with three log levels (Summary, Console, Debug) and DinoAI-powered failure analysis.

5. A Google Sheets candidate tracker that auto-updates with scores, strengths, gaps, and pass/fail status.

The beauty of this setup is what you didn't have to do: no local cron daemon configuration, no Docker containers for a simple script, no manual credential file management, no SSH-ing into a server to check if your job ran.

Paradime Bolt handles the orchestration. OpenClaw handles the AI. You handle the hiring decisions.

Next Steps

• Refine your scoring prompt — Add specific technical skills, years of experience thresholds, or culture-fit criteria to the system prompt

• Add a Slack notification for high-scoring candidates — Trigger an immediate alert when a candidate scores 90+

• Expand to multiple job roles — Use schedule-level environment variable overrides to run different JOB_CRITERIA for different positions

• Connect to your ATS — Replace Google Sheets with API calls to Greenhouse, Lever, or Ashby

Resources

• Paradime Documentation

• Bolt Python Scripts Guide

• Bolt Environment Variables

• Bolt Schedule Trigger Types

• Debugging Failed Bolt Runs

• OpenClaw Getting Started

• OpenClaw Environment Variables

• Google Workspace Automation Skill

• Gmail API Python Quickstart