DEV Community: Anthony Emmanuella Mmasinachi

Your Database Has Permissions. But Can You Prove They're Working?

Anthony Emmanuella Mmasinachi — Sun, 25 Oct 2026 09:51:22 +0000

Most developers focus on securing their databases.

But here's a harder question:

Can you actually prove your security policies are being enforced?

A database connection working doesn't mean tenant isolation is working.

An authentication system working doesn't mean every data access is authorized.

And having security policies doesn't automatically mean they're effective.

That's one of the problems Agata Proxima was built to address.

A PostgreSQL security platform designed to help developers:

Enforce tenant-aware security policies.
Verify access controls.
Monitor database activity.
Maintain auditable security records.
Add protection without replacing PostgreSQL.

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

Explore the platform: https://agataproxima.com

A question for backend engineers and security architects:

If your CTO asked you to prove that one tenant cannot access another tenant's data, what evidence would you show?

Your PostgreSQL Database Is Secure. But Are Your Tenants?

Anthony Emmanuella Mmasinachi — Sun, 25 Oct 2026 09:45:59 +0000

One missing tenant filter. One overlooked authorization check. Suddenly, Customer A can access Customer B's data.

That's the nightmare of multi-tenant SaaS applications.

So I built Agata Proxima.

A PostgreSQL security platform with an open-source Rust proxy designed to strengthen tenant isolation, enforce security policies, verify access controls, and provide auditable security records.

No database migration. No replacing PostgreSQL. An additional security layer.

The engine is open source. Inspect the code, challenge the architecture, or try it yourself.

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

Website: https://agataproxima.com

Here's my question for PostgreSQL developers:

Would you trust application-level tenant isolation alone, or would you want an independent security layer between your application and database?

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

Anthony Emmanuella Mmasinachi — Sun, 25 Oct 2026 08:01:08 +0000

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.