Trigger.dev Unlocks Secure SQL Access on Shared ClickHouse

industry sources tracked this implementation closely because it addresses a genuine blocker for teams building on shared infrastructure. When multiple customers query the same ClickHouse cluster, you face a hard choice: either run isolated clusters (expensive, complex), or grant SQL access and risk data leaks between tenants. Trigger.dev found a third path.

The core tension is straightforward. ClickHouse excels at analytical queries across massive datasets. But in a multi-tenant SaaS context, that same power becomes a liability - one misconfigured query can expose another customer's data. Most platforms either lock users out of direct SQL entirely, or implement row-level security that's brittle and hard to audit.

Trigger.dev needed developers to write custom SQL workflows while running everything on shared infrastructure. CEO Matt Aitken outlined their solution in the ClickHouse March 2026 newsletter, detailing an approach that enforces isolation at the query layer without requiring separate cluster instances.

• Multi-tenant ClickHouse access without dedicated clusters per customer
• SQL query capability preserved for custom workflows
• Isolation enforced at query execution time, not application logic

The implementation relies on query interception and tenant-aware execution contexts. Rather than trusting application code to filter results, Trigger.dev wraps ClickHouse queries with automatic table/database scoping tied to the authenticated user context. This means a developer's SQL query gets rewritten at execution time to include invisible but enforced WHERE clauses that limit results to their tenant's data.

This differs from traditional row-level security because it operates outside the database's native RBAC system. The isolation layer sits between the application and ClickHouse, examining every query before it reaches the cluster. If a developer writes SELECT * FROM orders, the system automatically appends AND tenant_id = X before execution.

The approach trades some operational complexity for security clarity. You don't have to debug ClickHouse's built-in security features or worry about privilege escalation through role misconfigurations. Every query, regardless of author intent, gets scoped to the tenant. This is verification through design rather than prevention through restriction.

Audit trails become simpler too. Every query hitting the cluster is already tagged with tenant context, making it trivial to track who accessed what data and when.

• Query rewriting layer intercepts SQL before ClickHouse execution
• Automatic tenant-id injection into WHERE clauses
• No changes needed to ClickHouse schema or configuration
• Centralized audit trail tied to authenticated user context

If you're running a data platform or analytics tool where customers need query access, this shifts the cost-benefit analysis. The old binary choice - isolate clusters or lock down SQL access - no longer applies. You can offer SQL flexibility while running at shared infrastructure cost.

The implementation does introduce a new failure mode. If the query rewriting layer fails or gets bypassed, isolation fails entirely. This means your monitoring strategy needs to watch not just ClickHouse performance, but also the correctness of the query rewriting system. Every tenant can now see if their queries are being properly scoped.

For teams currently using row-level security or application-level filtering, this approach gives you a reference implementation for moving isolation enforcement upstream. It's a reminder that security architecture decisions aren't binary - you have more options than 'database-native' or 'application-level.'

Trigger.dev's contribution here, documented in the ClickHouse newsletter, gives other builders a tested pattern. You're not inventing isolation from scratch; you're following a proven path. The work now is adapting this to your specific data model and query patterns. The momentum in this space continues to accelerate.

• Shift from cost-prohibitive isolation to shared infrastructure with hard guarantees
• Add monitoring for query rewriting layer correctness alongside database metrics
• Consider this pattern if you currently split multi-tenant access between locked-down and risky options