I Built an Open-Source Rust Proxy to Strengthen PostgreSQL Tenant Isolation

I Built an Open-Source Rust Proxy to Help Prevent Cross-Tenant Data Leaks in PostgreSQL

Tags: "#postgres" "#rust" "#opensource" "#security"

Building a multi-tenant SaaS application comes with a security challenge that doesn't always get enough attention:

What happens when one tenant accidentally gains access to another tenant's data?

In many SaaS applications, multiple customers share the same PostgreSQL database.

Developers rely on application-level authorization, tenant filters, and sometimes PostgreSQL Row-Level Security (RLS) to keep customer data isolated.

These approaches can work well. But a missing tenant filter, an incorrect authorization check, or a misconfigured policy can introduce serious security risks.

That problem got me thinking:

What if we could introduce another security enforcement layer between an application and its PostgreSQL database?

That's the idea behind Agata Proxima.

Introducing Agata Proxima

Agata Proxima is a PostgreSQL security platform built around an open-source Rust proxy engine.

It's designed to help developers strengthen tenant isolation, enforce security policies, verify access controls, and maintain auditable security records without replacing their existing PostgreSQL database.

The architecture introduces a security layer between applications and PostgreSQL:

 SaaS Application
        |
        v

Agata Proxima Engine
(Rust Proxy)
|
v
PostgreSQL

The goal isn't to replace PostgreSQL's existing security capabilities.

It's to provide an additional layer of protection and visibility for applications where tenant isolation matters.

Why Rust?

I chose Rust for the proxy engine because of its memory-safety guarantees, performance characteristics, and suitability for building infrastructure software.

For a component sitting between an application and its database, efficiency and reliability are important engineering considerations.

More Than Just a Proxy

Alongside the open-source engine, I've built the Agata Proxima platform with capabilities for:

• Tenant management and security policies
• Access verification
• Database activity monitoring
• Audit records and security attestations
• Engine node management
• Developer APIs and integrations

The engine is open source, allowing developers to inspect the implementation and explore how it works.

Explore the Project

Open-source Rust engine:

https://github.com/Agata-Proxima/proxima-engine

Official website:

https://agataproxima.com

If you work with PostgreSQL, Rust, database infrastructure, or multi-tenant SaaS applications, I'd love your technical perspective.

A Question for PostgreSQL Developers

If you were introducing a security proxy between your application and PostgreSQL, what would concern you most?

Performance overhead? Connection management? Compatibility? Operational complexity? Or something else?

I'm especially interested in hearing from engineers who have dealt with tenant isolation challenges in production.

I'd love to hear your thoughts in the comments.