How do I set up scheduled Gumloop reports that query Snowflake/BigQuery/Databricks and post results to Slack?

“Can you send a quick pipeline health report from Snowflake to #gtm-leadership every morning at 8am?”

That’s the job: a recurring, trustworthy report that hits Slack on time, built once and then left to run in the background. With Gumloop, you can wire this up in a few minutes—querying Snowflake, BigQuery, or Databricks—without asking engineering to build a one-off cron job or notebook.

Quick Answer: Use Gumloop to build a Workflow that (1) runs on a schedule, (2) queries Snowflake/BigQuery/Databricks, (3) formats results, and (4) posts into a Slack channel. Once configured, the Workflow runs automatically, so your reports show up as finished Slack messages instead of ad-hoc data pulls.

Why This Matters

If you’re pulling the same metrics from your warehouse every week, you’re burning ops time on copy-paste work that should be fully automated. Scheduled Gumloop reports turn recurring analytics asks into an always-on workflow: the agent runs your query, formats the output, and posts it into Slack at the exact cadence you pick.

Instead of:

Hunting for the right SQL
Opening Snowflake/BigQuery/Databricks manually
Exporting to CSV or Sheets
Screenshotting and posting into Slack

…you define the workflow once and let Gumloop handle the triggers, tool calls, and Slack posts in the background.

Key Benefits:

Zero manual reporting: Eliminate repetitive “can you pull this from Snowflake?” tasks with scheduled, reliable reports.
Live data where teams work: Results land directly in Slack channels your GTM, product, or ops teams already use.
Production-grade control: Maintain governance with audit logs, model restrictions, and enterprise security while automations run at scale.

Core Concepts & Key Points

Concept	Definition	Why it's important
Scheduled Tasks for Workflows	Gumloop’s ability to run Workflows on recurring schedules (e.g., every weekday at 8am).	Turns one-off automations into always-on systems that deliver reports without manual triggers.
Warehouse Connectors (Snowflake/BigQuery/Databricks)	Integrations that let Gumloop agents run SQL against your data warehouse using secure credentials.	Ensures reports are powered by your live production data, not stale exports or spreadsheets.
Slack Delivery	Workflow steps that post messages (and optionally files) into specific Slack channels or threads.	Puts finished reports in the same place your teams already make decisions and follow up on data.

How It Works (Step-by-Step)

At a high level, you’ll:

Connect Slack and your warehouse to Gumloop.
Build a Workflow that runs SQL and formats the result.
Add a schedule so the Workflow posts reports into Slack automatically.

Here’s what that looks like in practice.

1. Connect your tools to Gumloop

First, make sure Gumloop can talk to both your warehouse and Slack.

Add Slack:
- In Gumloop, go to Integrations.
- Select Slack and authorize the Gumloop app in your workspace.
- Confirm the app can post in the target channels (e.g., #gtm-reports, #product-insights).
Add Snowflake / BigQuery / Databricks:
- In Integrations, choose the warehouse you use:
  - Snowflake: Provide account URL, warehouse, database, schema, and a service user with read access.
  - BigQuery: Connect via service account JSON or OAuth with appropriate dataset permissions.
  - Databricks: Configure workspace URL, personal access token/service principal, and target catalog/schema.
- Test the connection with a simple query (e.g., SELECT 1) to confirm access.

Once these are wired up, Gumloop can call the warehouse via tools and send messages into Slack as part of a Workflow.

2. Design the reporting Workflow

Next, build the Workflow that will actually run your query and prepare the Slack-friendly output.

In Gumloop’s visual canvas:

Create a new Workflow:
- Click New Workflow.
- Name it something specific like Daily Snowflake GTM Pipeline Report or Weekly Databricks Product Health.
Add a “Run SQL” node:
- Choose the integration:
  - “Query Snowflake” / “Query BigQuery” / “Query Databricks” (depending on what you connected).
- Paste your SQL. For example, for Snowflake:
```
SELECT
  date_trunc('day', created_at) AS day,
  COUNT(*) AS new_opportunities,
  SUM(amount) AS pipeline_created
FROM sales_opportunities
WHERE created_at >= dateadd('day', -7, current_date())
GROUP BY 1
ORDER BY 1 DESC;
```
- Parameterize where useful (e.g., {{days_back}}, {{owner_team}}) so you can reuse the Workflow later with variations.
Add a “Format report” node (using an agent):
- Insert an AI formatting or Reasoning Agent node after the SQL node.
- Pass the query result (rows/JSON) as input.
- Prompt the agent to:
  - Summarize the key takeaways.
  - Highlight deltas vs. the previous period (if you include that in your SQL).
  - Surface 3–5 bullets for GTM/leadership.
  Example prompt:
  “You are a Data Analysis Agent summarizing a recurring GTM pipeline report. Given the SQL result below, generate:
  - A 1–2 sentence executive summary.
  - A bullet list of key changes vs. last week.
  - Any anomalies that a sales leader should investigate. Output in plain-text Markdown suitable for a Slack message. Avoid SQL or technical jargon.”
- Because Gumloop supports every model out of the box, admins can control which models this agent uses and set restrictions via RBAC and model policies.
Add a “Post to Slack” node:
- Add a Slack → Send message node.
- Choose the target channel (e.g., #gtm-leadership, #data-daily).
- In the message body, reference the formatted output from the previous node, and optionally add a header:
```
:bar_chart: Daily GTM Pipeline Report (Snowflake)
Date: {{current_date}}

{{formatted_report_output}}

_Powered by Gumloop — query + summary auto-generated._
```
- Optionally, also:
  - Attach a CSV or table rendering as a file.
  - Post a short version to leadership and a longer, more detailed version to a data channel using two Slack nodes.

At this point, you have a Workflow that can be run manually to fetch the latest data, summarize it, and post into Slack.

3. Add scheduling so reports run automatically

Now you turn the Workflow into a scheduled report.

In the Workflow, go to Triggers / Schedule.
Add a Scheduled Task:
- Choose the cadence:
  - Daily, weekdays only, weekly on Mondays at 9am, or custom CRON-like configuration depending on your needs.
- Set the time zone to match your team (e.g., America/Los_Angeles for West Coast GTM).
Configure any parameters:
- If your SQL uses dynamic parameters (like days_back or team), set defaults as part of the scheduled run.
- Example: A daily report with days_back = 1 vs. a weekly report with days_back = 7.
Save and enable the schedule.

Gumloop will now execute the full pipeline—warehouse query → agent formatting → Slack message—on that schedule, without you touching anything.

4. Add guardrails and observability (optional but recommended)

For production-ish reporting that leadership depends on, you’ll want controls:

Role-based access control (RBAC):
- Restrict who can edit the Workflow, especially the SQL and Slack destinations.
- Limit who can access the warehouse credentials.
Audit logging & usage monitoring:
- Track when the Workflow runs, which model was used, and what data was accessed.
- Use Gumstack (Gumloop’s security and observability layer) if you need more granular monitoring and MCP infrastructure-level controls.
Model governance:
- Set AI model restrictions so the Data Analysis Agent only uses approved models (and optionally via an AI proxy).
- Enforce Zero Data Retention and custom retention rules so report content isn’t used to train models and complies with internal policies.

Once these are set, your scheduled reports behave like any other production system: observable, governable, and safe to rely on.

Common Mistakes to Avoid

Using a brittle SQL query without guardrails:
If your query references experimental tables or columns that change frequently, reports will break.
How to avoid it: Point scheduled reports at stable, versioned views or curated marts. Log SQL errors in Gumloop and notify a data channel when a run fails.
Posting to the wrong Slack audience or channel:
A noisy, raw data dump in a leadership channel will get ignored.
How to avoid it: Use the Data Analysis Agent to create an executive summary for leadership and send detailed tables to a dedicated data or ops channel. Always label reports clearly with the data source and date range.

Real-World Example

Let’s say you’re running GTM ops and keep getting this Slack ping:

“Hey, can we get a daily summary of new qualified opportunities from Snowflake, broken down by region, posted to #gtm-leadership?”

Here’s how this looks with Gumloop running the show:

You build a Workflow that:
- Queries Snowflake for yesterday’s qualified opportunities by region plus WoW change.
- Passes the result to a Data Analysis Agent to produce:
  - 2–3 sentences on headline movement.
  - A short bullet list of regions up/down with percentages.
- Posts the result into Slack in #gtm-leadership at 8am every weekday.

The next morning, leaders open Slack and see:

:bar_chart: Daily Qualified Opportunities (Snowflake) — 2026-04-12

Summary:
- Qualified opportunities increased +11% vs. yesterday, driven primarily by EMEA.
- North America is flat; APAC declined slightly due to fewer inbound trials.

Key Highlights:
- EMEA: +22% (41 → 50 opps), topline pipeline +$420K.
- NA: +1% (73 → 74 opps), pipeline stable.
- APAC: -8% (24 → 22 opps), watch inbound demo volume.

Next Actions:
- GTM ops will investigate APAC inbound sources and share a follow-up note in #gtm-apac by EOD.

_Source: Snowflake `mart_opp_daily_rollup` — automated via Gumloop._

No one had to:
- Open Snowflake.
- Rewrite SQL.
- Export and format spreadsheets.
- Manually compose the Slack update.

You’ve moved from “We remember to pull this when someone asks” to “It’s just there every morning, with context, in Slack.”

Pro Tip: Start with one narrow report (e.g., “daily qualified opps by region from Snowflake to #gtm-leadership”), get it consistently working, and then clone the Workflow to create variants for BigQuery/Databricks or other teams. Reuse the same Data Analysis Agent and Slack formatting so your reporting feels consistent across the company.

Summary

Scheduled Gumloop reports are just Workflows with three ingredients: a warehouse query, an agent that understands the result, and a Slack message as the artifact. Once you connect Snowflake/BigQuery/Databricks and Slack, you can build these in minutes—then let scheduled tasks run them in the background, every day or week, without human intervention.

The result: leaders and teams get timely, Slack-native insights backed by your production warehouse, while ops and data folks stop burning cycles on repetitive reporting. With RBAC, audit logs, model restrictions, and options like Zero Data Retention, you can treat these workflows as production systems, not fragile scripts.

Next Step

Get Started