An Architecture That Doesn't Tire as You Grow
This page is for your IT team and decision makers: here's what sits underneath RiverAI, and why it is a foundation you can trust.
No Microservice Complexity, No Monolith Constraints
RiverAI is built as a modular monolith on .NET 10; it preserves the discipline of modularity without taking on the operational burden of microservices. In a microservice architecture, each business domain is deployed as a separate service; that brings separate deployment pipelines, network latency between services, and the complexity of distributed transactions (questions like what happens when one operation is left half-done across five services). RiverAI draws clear module boundaries at the code level without carrying that burden: each business domain (processes, forms, identity, invoicing) lives in its own module, under its own responsibility, but they talk to each other within the same process, not through direct network calls.
The practical consequence of this approach is this: violating a module's boundaries (for example, the form module reaching directly into invoicing tables) is caught at compile time or in code review, because inter-module dependencies are explicitly defined. At the same time, since it is deployed as a single application, deployment, monitoring, and logging are managed from one place; instead of searching ten different log files across ten services for "which one slowed down and why," you observe the behavior of a single application.
This architectural choice also provides flexibility when moving from a small installation to a large enterprise scale: adding a new module doesn't require rewriting existing modules or standing up a new service mesh; the module joins under the same discipline, as part of the same deployment unit.
Version-Controlled Database Changes
In RiverAI, the database schema is managed not with hand-written one-off SQL scripts but with EF Core code-first migrations. Every schema change (a new table, a new column, a changed relationship) enters the codebase as a versioned, ordered, and reversible migration file. Like the rest of the code, these files are tracked in source control (git); when a change was made, by whom, and for what purpose is always visible.
The concrete benefit shows up when going to production: a migration is compared against the target environment's current schema and only the missing steps are applied in order; a sequence like "first add this table, then backfill that column, then drop the old column" runs safely and repeatably. If something goes wrong, the migration can be rolled back; the schema can be restored to its pre-change state. That turns every deploy from a "let's hope it works" moment into a predictable operation.
There is a similar discipline on the frontend: the interface, written in React and TypeScript, is built with Vite, providing a fast development loop (a code change appears in the browser within seconds) and end-to-end type safety (a model change on the backend is caught instantly as a compile error on the frontend). Both schema and interface evolve with the same discipline: step by step and traceably.
Isolation That Is Also Performance
On PostgreSQL, each module has its own schema: the process module lives in its own schema, the form module in its own, and no module can reach directly into another's tables. This is the code-level modular boundary reflected into the database: changing a module's internal data structure carries no risk of breaking another module, because the only point of contact between them is a set of explicitly defined interfaces.
At the same time, these schemas share a single database instance: not separate database servers, but one PostgreSQL instance, one backup regime, one transaction boundary. This choice delivers isolation and operational simplicity at once: thanks to schema separation the modules don't bleed into each other, but thanks to the single instance, backup, monitoring, and capacity planning are run from one place; instead of trying to keep ten separate databases in sync, you watch the health of a single database.
Tenant isolation works by the same logic: one customer's heavy usage doesn't slow down the neighboring tenant, because data and query boundaries are separated from the start. Adding a new module doesn't disturb the existing system either; the module joins with its own schema and its own area of responsibility; RiverAI's growth never requires a customer to rewrite their existing system or migrate their data.
- Modular Monolith: clear module boundaries on .NET 10: the discipline of modularity, without the network latency and distributed-transaction complexity of microservices.
- Schema-Based Isolation: each module (process, form, identity, invoicing) has its own PostgreSQL schema; changing one module's internals carries no risk of breaking another.
- Single Database Instance: all schemas share one PostgreSQL instance: one backup regime, one monitoring point, none of the burden of managing ten separate servers.
- EF Core Migrations: every schema change is tracked in git as a versioned, ordered, and reversible migration file.
- Tenant Isolation = Performance Isolation: one customer's heavy usage doesn't slow down the neighboring tenant; adding a new module doesn't disturb the existing system.
Proven Technologies, Carefully Assembled
We built RiverAI not with an exotic technology invented from scratch, but with mature components the industry trusts; a foundation that reduces risk and that your team will find familiar too.
.NET 10
The backend core: modular monolith architecture, high performance, long-term Microsoft support.
PostgreSQL
Each module in its own schema; an open-source, proven, scalable relational database.
React + TypeScript
All design tools and interfaces: a type-safe, modern, browser-based frontend.
Keycloak
Identity and access management: the industry-standard, open-source IAM solution.
SignalR
Real-time communication: kanban boards, multi-user design synchronization.
Anthropic Claude
The AI generation engine: process/form generation, visual analysis, natural language understanding.
OnlyOffice
In-browser document editing: open, edit, and save Word/Excel files without downloading them.
EF Core Migrations
Version-controlled schema evolution: every change is traceable and reversible.
All Design Tools, Straight in the Browser
The process designer, form designer, dashboard designer: all fully web-based, written in React and TypeScript, running straight in the browser. No installation, no remote desktop connection (RDP), no VPN, no physical or virtual access to a specific Windows machine. A browser tab and an internet connection are everything you need to start designing.
This is real relief, especially for organizations coming from legacy desktop-based systems: previously, touching a process meant first connecting to the VPN, then logging into a remote server with an RDP client, then launching the designer application; every step a delay, a point of failure, a potential IT ticket. In RiverAI, that entire chain disappears: the designer, the IT team, a field worker, even an external consultant; everyone accesses it directly from their own computer, phone, or tablet by opening the same address.
The operational consequence is just as concrete: no machine that must keep an RDP session open, no burden of keeping a "who can access which server" list current, no remote desktop licenses or bandwidth constraints. When a designer wants to push a change live, the only step in between is opening the browser.
- Fully Browser-Based: the process, form, and dashboard designers are written in React/TypeScript and run straight in the browser; no installation, RDP, or VPN required.
- Design = End-User Layer: a designer, the IT team, or an external consultant accesses the same address from their own computer, phone, or tablet.
- Zero Access-Infrastructure Burden: no RDP session that must stay open, no "who can access which server" list, no remote desktop license or bandwidth constraint.
- End-to-End Type Safety: the Vite-built frontend catches a backend model change instantly as a compile error.
Let's Discuss the Architecture with Your IT Team
Let's schedule a technical session and answer your questions directly.
Request a Demo