Upsolve Row-Level Security

Product Introduction

1. Definition: Upsolve Row-Level Security is a server-side data access control layer specifically designed for AI data agents and multi-tenant SaaS applications. It operates as a security middleware that intercepts and modifies database queries before execution, applying deterministic, rule-based filters based on user and organizational properties.
2. Core Value Proposition: It exists to provide a deterministic, non-bypassable security model for AI agents, eliminating the risk of data leakage through prompt injection, hallucination, or agent error. Its primary value is enabling secure, multi-tenant AI deployments by enforcing hard data isolation at the query level, separate from the agent's logic.

Main Features

1. Server-Side Pre-Filters: Every SQL query, whether generated by an AI agent, a BI tool, or a human, is intercepted by the Upsolve layer. The system programmatically appends a WHERE clause based on pre-configured security rules before the query is sent to the underlying database. This happens transparently, ensuring no raw, unfiltered data is ever exposed to the requesting client or agent.
2. Property-Based Rule Engine: Security rules are defined globally using a combination of user/organization properties (e.g., user.country, org.tenant_id) and database schema. A rule like column.country = user.country automatically applies to all tables containing a country column. For complex logic, custom SQL rules can be written for specific tables.
3. Rule Simulation & Testing Environment: A critical feature for security audits and development. Administrators can impersonate any user and preview the exact SQL filter that will be applied to a given query. This provides verifiable proof of data isolation for compliance and allows for rigorous testing before deployment.

Problems Solved

1. Pain Point: Reliance on prompt-based instructions (e.g., "only show data for the current user") as a primary security mechanism is fundamentally flawed and insecure for production AI applications. This approach is vulnerable to prompt injection, agent confusion, and lacks auditability.
2. Target Audience: Chief Technology Officers (CTOs) and engineering leads at B2B SaaS companies building multi-tenant AI features; Security and Compliance officers requiring provable data isolation; Product teams launching AI agents that interface with customer data.
3. Use Cases: Deploying a single AI data analytics agent across thousands of SaaS customers, where each tenant must only see their own rows. Enabling secure customer-facing dashboards or chatbots that query a shared database. Passing security reviews by demonstrating exact row-level access controls per user role.

Unique Advantages

1. Strengths & Limitations (Pros & Cons):

   • Pros:
     • Non-Bypassable Security: The agent's context is completely separate from the security layer, making traditional prompt attacks irrelevant.
     • Deterministic & Auditable: Rules are code, not suggestions, providing clear audit trails.
     • Architectural Simplicity: Allows deployment of a single, unified agent backend instead of per-tenant instances.
     • Performance: Filtering at the query level is typically more efficient than fetching and filtering data in application logic.
   • Cons:
     • Vendor Lock-in: Introduces a dependency on Upsolve's proprietary rule engine and middleware.
     • Learning Curve: Requires defining a security ontology (users, orgs, properties) and translating access policies into Upsolve's rule syntax.
     • Potential Latency: Adds an extra network hop (the Upsolve layer) for every database query, though this is typically minimal.

2. Key Alternatives & Differentiation:

   • Database-Native RLS (PostgreSQL, etc.): A robust alternative. Upsolve differentiates by offering a database-agnostic layer, a centralized management console for rules across multiple data sources, and a user-friendly testing interface that database-native RLS lacks.
   • Application-Level Filtering: Manually adding WHERE clauses in application code. Upsolve differentiates by centralizing and externalizing security logic, reducing human error, and making rules consistently apply to all data access paths (agents, APIs, tools).
   • Competitor Platforms (e.g., Supabase Auth + RLS): Supabase bundles PostgreSQL RLS with an auth system. Upsolve differentiates by being explicitly focused on the AI agent use case, with features like rule invisibility to the agent and integration into a broader "Agent Stack" for ongoing improvement.

Frequently Asked Questions (FAQ)

1. Can an AI agent or a clever user prompt bypass Upsolve Row-Level Security rules? No. The rules are enforced server-side in the Upsolve data plane. The SQL query is modified before it reaches the database, and the AI agent never receives the unfiltered query or the rule logic to attempt to circumvent it.
2. How does Upsolve handle complex security rules that require joins between tables? For rules that cannot be expressed with simple property-to-column matching, Upsolve allows administrators to write custom SQL rules. This SQL is executed by the Upsolve layer, using the contextual user properties, to dynamically generate the correct filter for the primary query.
3. Is Upsolve Row-Level Security only for AI agents, or can it be used for traditional applications? While optimized for the AI agent paradigm, it is a general-purpose row-level security solution. It can secure data access for any client, including web applications, mobile apps, and BI tools, by centralizing and enforcing data governance policies.
4. What happens if a user is missing a property required by a security rule? Upsolve provides configuration options. Rules can be set as "optional" (skipped if the property is missing) or "required" (the query will be blocked or return no data if the property is absent), allowing for flexible security postures.
5. How does Upsolve impact query performance? The primary performance impact is the network latency of routing queries through the Upsolve proxy. The rule application itself is designed to be lightweight. For most applications, this overhead is negligible compared to the security and management benefits, and it is often faster than application-level filtering.