Half of a team writes not the business but everything around it. How **redb **takes that half off your hands, and why with it an analyst with AI can build an integration.
How many people on your team write the wrapping around the business? The broker connection, the database migration, the zero-downtime deployment, the dashboard, the login. It has to be done, it costs money, and it is the same everywhere. You pay for that work again in every project, and now you pay for it in tokens too: the AI writes the same plumbing, gets it wrong and rewrites it on your bill.
redb has already written that part. It is an open .NET ecosystem: data storage, an integration engine, a host for modules and a login server. This article is about how many people and how much AI work are left when everything around the business is already there.
What it looks like
Three rules.
Data is a class. You write a plain C# class, put an attribute on it, and redb stores it in PostgreSQL, SQL Server or SQLite:
[RedbScheme("employee")]
public class EmployeeProps
{
public string FirstName { get; set; } = "";
public decimal Salary { get; set; }
public string[]? Skills { get; set; }
}
A process is a route. For example: pick up XML files from a folder, check them against a schema and send them to Kafka. A good file moves to done, a bad one to error, where a person can look at it:
<route id="orders-in">
<from uri="file://inbox?antInclude=*.xml&moveTo=done&moveFailed=error"/>
<convertBody type="System.String"/>
<validateXsd file="resources/order.xsd" throwOnFailure="true"/>
<to uri="kafka://orders?brokers=kafka:9092"/>
</route>
An external system is an address string. file://, kafka://, sftp://, soap://, as4://: redb.Route has 30 transport packages and 53 address schemes, from brokers and databases to mail, SOAP and European document exchange. To connect to a system, you name its connector.
Where the hours go
Tables and migrations. A new entity usually starts with a meeting: which tables, which relations, which indexes, who writes the migration. Here an entity is a class. Foreign keys, indexes and uniqueness are already in place, and the schema follows the class at startup. The limit: a field removed from the class is removed from the database by default. When an old and a new version of the application run side by side, you turn that mode off.
One example shows it best. The business says: "Let's keep an employee's skills, several of them." In a usual schema that is a fork. Either a separate table: a migration, a foreign key, an index, a join in every query, mapping code. Or a JSON string: cheap today, awkward to search by element, and redone at the next change of requirements. Even with AI that is hours: the model writes either option, but choosing, checking and later redoing it is people's work.
In redb it is one line in the class above, public string[]? Skills. You can search right away:
var devs = await redb.Query<EmployeeProps>()
.Where(e => e.Skills != null && e.Skills.Contains("C#") && !e.Skills.Contains("Python"))
.ToListAsync();
Each skill is stored as its own row with a foreign key to the employee. The developer describes what an employee is, and the system decides how to lay it out in tables. That is why the business can afford to experiment: a new field is one more property of a class.
Speed. The usual question: isn't this slower than "normal tables"? We checked on the same employee model, which a usual schema spreads over 41 tables. We took the 98 tasks EF Core can do without raw SQL and timed one run of each: redb Pro on PostgreSQL took 189 ms on average, EF Core 703 ms. EF Core is faster where data is flat or where there are many small saves of one object each. If that is your profile, use EF Core. Every example with its time and query count is on the results page, and anyone can repeat the run.
Integrations. A broker connection with retries, dead letters and deduplication usually takes a week to write and a month to fix. Here it is an address string plus ready integration patterns: retry, content-based routing, aggregation, idempotent intake. A transaction in a route is one word: first the database commits, then the sends to brokers go out, then the incoming message is acknowledged, always in that order. The limit: it is not a distributed transaction. HTTP, mail and files run at once, and processes that last hours need a pattern of their own.
Deployment and operations. Routes live as modules in the redb.Tsak host. You drop a new module into a folder, and the host picks it up without stopping the other modules or losing messages in flight. The dashboard, metrics, OpenTelemetry traces and the log are already there. A message a route sent to the host's dead letter queue is replayed or discarded by an operator from the console, with no developer woken up for it. There is a cluster with leader election and signed images. The limit: the server, the OS, TLS and database backups are still your administrator's job, there is just less of it.
Login. redb.Identity is an OAuth 2.1 and OpenID Connect server that installs as a package. We run it against the OpenID Foundation's official test suite: no module fails in the Basic OP and Config OP plans. Three modules need a person to take a screenshot in the browser; they last passed by hand in July. We don't carry the OpenID Certified mark, which is a separate paid procedure.
Document exchange with Europe. If your partner in the EU requires AS4 (e-invoicing, customs, energy, the public sector), the usual answer is a separate Java server next to the application. Here it is a connector. In November its version 4.6.1 passed the European Commission's conformance testing: eDelivery AS4 Profile 1.16, Common Profile, 76 of 76 required tests. The Commission has put redb.Route.As4 on its list of conformant products.
The limit: the certificate is for 4.6.1, later versions have not been through the tests again. It covers the eDelivery common profile. Peppol has a profile of its own, and we have not been tested against it.
The analyst and the AI
With the redb libraries, an analyst with AI can run an integration project.
Here is how it works. The analyst knows the process: where an order comes from, what to do with it, where to send it. The AI knows the markup. The ecosystem knows the technology. The analyst states the task in words, the AI builds an XML route from ready connectors and patterns, and then the checks take over.
Every project created from a template already has an AGENTS.md file with rules for GitHub Copilot, Cursor, Codex and Claude Code: elements only from the schema, secrets only as configuration keys. The markup schema is generated from the real packages. If the model still makes up an element or an option, the package check refuses it before deployment: it names the file, line and column, and answers a typo with "'perod' is not an option of the Timer endpoint. Did you mean 'period'?". The VS Code extension completes from the schema and draws the route as a graph: the analyst looks at the picture and sees whether the process is built right.
The analyst checks what the process means; the machine checks the syntax. That is where the savings come from. Fewer people in the chain: no developer translating the analyst's words into code and then explaining why it came out wrong. And a shorter loop of "the AI wrote it, it failed, the AI rewrote it": the check catches the error before it reaches a server. We have not measured how many tokens this saves.
The limit: an analyst with AI builds routes from what is there. That is connectors, integration patterns, calls to your services, redb objects. Your own code with business calculations is written in C#, and that is a developer's work. A connector that is not on the list is C# work too. The developer stays on the team and no longer writes the plumbing.
What it costs and what you risk
In money, nothing. The core, the integration engine, the host and the login server are open source under Apache 2.0. The Pro packages are closed but free: no key, no limits, commercial use included. Everything runs inside your perimeter, the data stays in your database, and nothing goes out. The open part lives in four public repositories, tests included.
Releases come often: eight weeks from 4.0 to 4.7. There is no long-term support branch, but the 4.7.x line gets fixes for critical defects and fixes on request. It is the last line on .NET 8 and 9: Microsoft ended their support on 10 November, and from 4.8.0 on the packages target .NET 10 and 11 only. And somebody has to run the host: ordinary administrator work.
How to try it in a day
One redb-tsak-stack container brings up the host and the dashboard on SQLite, with no external database and no key. One template creates a route project:
dotnet new install redb.Templates
dotnet new redb-route-file -n Orders
There are 21 route templates: files, Kafka, RabbitMQ, mail, REST, AS2, AS4, redb storage and more. The module goes into the modules/ folder, the host picks it up, and the route shows up on the dashboard.
What we suggest
Not a migration. A pilot: one module, one integration that hurts you today. Take a process a developer looks after now, give it to an analyst with AI, and see how many people and how much time it takes. If it doesn't fit, you lose a day.
Code and documentation: github.com/redbase-app. More on what the ecosystem replaces and what it costs in the article for those choosing a platform.
Which integration would you hand to an analyst first? Tell us in the comments.
If this was useful, a ⭐ on GitHub helps others find it.


Top comments (0)