Siua Labs · Policy technology

Bring your rules into the decision.

Who can approve an expense? Does it meet the spending rules? Does it need another reviewer? Siua brings those questions together in policies your team can compose, test, and reuse.

Why we’re building this

Business rules belong in the decision.

Access often starts with who can act. The rest of the decision, including spending limits, verification, and exceptions,can end up scattered through application code.

Siua brings those rules into policies. Teams can review and test the whole decision, share the logic, and change a requirement without tracking down separate copies across applications.

Compose the decision

Let each policy do its part.

An allow can open the door. Enforce policies set the requirements that still have to pass. Add another allow below: it won’t bypass the spending limit.

Maya is an expense approver. Identity verification and the $2,000 spending limit are separate requirements.

Explore the policy verbs
Allow
Contribute a reason to allow the action.
Enforce
Require a condition to pass without granting approval itself. Every applicable requirement counts.
Observe
Record or act on an evaluation without changing its access decision.
Deny & escalate
Block an action, or give an exception a path to review.
Open the full explorer

Compose the logic

Build once. Use across policies.

A spending check can serve expense and purchase policies alike. Change the shared limit below and see both results change together.

Shared spending check
Expense policy$2,400Over limit
Purchase policy$2,800Over limit
See how functions are shared
export function withinLimit(amount: number, limit: number) {
  return amount <= limit;
}

Both policies import the same function:

import { withinLimit } from './spending';

withinLimit(request.amount, request.limit)
Edit a shared function

Developers can import shared functions and combine them using familiar language features, with the editors, code review, and AI tools they already use.

Make complexity manageable

Powerful rules should be easy to understand.

Policy-based authorization can bring a lot of rules together. The challenge is knowing what they mean and how they interact. Siua pairs expressive policies with tools to help people write, explain, and audit them.

Write with AI assistance

Use familiar code and AI authoring tools to turn a business requirement into a policy. Shared functions give authors reusable building blocks.

Read the meaning

Static analysis examines the policy code to explain its conditions and effects in plain English, so teams can review what the rule does.

Audit across the organization

Explore policies together to surface what actions can happen, under which conditions, and when. Find the rules behind a decision without searching through every policy by hand.

Explore authoring, analysis, and auditing

Build on the engine

Prefer roles? Build a familiar interface on top.

An RBAC wrapper can associate a name like Finance Manager with policy sets. People work with familiar roles while the policies retain their conditions, business rules, and composition.

An RBAC wrapper
Expense approval
Spending requirements

The wrapper selects the associated policy sets. Their policies evaluate the request with all their conditions and shared requirements.

Request details, such as organization, amount, or verification,can still shape the decision. The wrapper organizes access; the policies express the rules.

Across your systems

Keep the rule consistent wherever it’s used.

A business rule can cross applications, services, and teams. Sharing its execution logic helps keep a spending check or verification requirement from behaving differently in each place.

Write it once

Carry the rule across applications without recreating its logic for each technology.

Preserve its meaning

The same rule and facts lead to the same result, including operations such as text matching.

Review one implementation

Focus security review on shared execution behavior instead of maintaining separate versions that can disagree.

How does the same logic run across technologies?

Siua compiles policy logic into WebAssembly, a portable executable format. The host runs that program, carrying the same execution implementation with it.

One compiled implementationRecognize an expense reference
.NETMatches
RustMatches
PythonMatches

WebAssembly carries the same matching logic across hosts, so the rule’s meaning travels with it.

What happens to the TypeScript?

TypeScript is the first authoring language. The compiler translates policy logic into executable WebAssembly ahead of time. A host runs that compiled program without needing a JavaScript engine to execute the policy.

Operations such as regular expressions use the same implementation across hosts, rather than depending on each host’s own libraries.

Keep exploring

See what makes this approach different.

Compare approaches to access control, inspect the code, or try your own conditions in the explorer.