For consultancies: building integration projects faster and handing them over without pain
How many hours of your last project went into work the client doesn't want to pay for as a separate line? The broker connection, retries and duplicate protection, database migrations, deployment, monitoring. In the estimate it hides under "architecture" and "integration", and the client still asks why it takes so long.
I have been building backends for clients for over twenty years, and for the last three years and more I have built them on my own open source .NET ecosystem, redb. This article is about why it is a convenient stack for a firm that builds software for clients: what gets faster, what is easier to hand over, and where its honest limits are.
The same bricks at every client
The ecosystem is a data store, the redb.Route integration engine, the redb.Tsak host for modules and the redb.Identity login server. Data is a C# class, a process is a route, an external system is an address string. Every client gets the same project structure.
A project starts from a template. There are 21 for routes: files, Kafka, RabbitMQ, mail, REST, AS2, AS4, redb storage and more, plus templates for applications and a worker. In my experience the second project on this stack goes noticeably faster than the first, and the third faster than the second: decisions are not reinvented, and a new person on the team sees a familiar structure from day one.
An AI assistant that writes a route, not guesses
For a firm that sells hours this is probably the main point. Every project created from a template already has an AGENTS.md file with rules for GitHub Copilot, Cursor, Codex and Claude Code: which elements to use, how to keep secrets, what to check. A route is written in a typed DSL, and the XML schema is generated from the real packages, so the assistant works with what actually exists.
If it still makes up an option, the package check refuses it before deployment, names the file, line and column, and suggests the right name. The error is caught by a check on the developer's machine, not by the client's server. The assistant speeds the developer up but does not replace them: custom code with business calculations is still written in C#, and a person is responsible for it.
Clean code, if you keep to the DSL
Here is a route: read orders from Kafka, let only new ones through and send them to RabbitMQ.
From("kafka://orders?groupId=svc&brokers=localhost:9092")
.Filter(Header("type").isEqualTo("new"))
.To("rabbitmq://events?host=localhost");
The same in XML:
<route id="orders">
<from uri="kafka://orders?groupId=svc&brokers=localhost:9092"/>
<filter expr="header.type == 'new'">
<to uri="rabbitmq://events?host=localhost"/>
</filter>
</route>
Retries, error handling, transactions and dead letters are written in the same style. Code by different developers and from different projects looks the same, and reviews are not spent arguing about how to do it right. This is what a real route from a demo project looks like: schema validation, error handling, a decision and a reply in one transaction, with comments that read like a description of the process.

Hand-over: a diagram the client's analyst can read
After a hand-over the client is usually left with code that one person understands, and that person is yours. Here the process is a route, and a route can be shown as a picture. The redb-route-xml tool draws a Mermaid flowchart from an XML route:
redb-route-xml mermaid routes/main.route.xml --bin bin/Debug/net10.0
GitHub, GitLab and many Markdown viewers render Mermaid. The client's analyst looks at the diagram and checks that the process works as agreed, with no developer in the room. There is a free VS Code extension that shows the same route as a graph over the XML, and the redb Route: Show Mermaid Diagram command opens the Mermaid diagram in the next tab, no terminal needed:

The client depends less on one person, and you spend less time explaining.
A licence with no line in the estimate
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. Rather than paraphrase, here is what the Pro licence itself says:
install, configure, and run the Software, for any lawful purpose, including in commercial and production environments (§2.1 a)
no limit on the number of developers, servers, or requests (§2.1 b)
Allow the Licensee's employees, contractors, and agents to use the Software on the Licensee's behalf (§2.1 d)
The Software is provided free of charge. No purchase, payment, license key, activation, subscription, or renewal is required (§2.2)
Distributing an application that merely uses the Software as a dependency is permitted (§3.1 a)
For a consultancy this means: you build a solution for a client on redb, the client runs it in its own environment, and neither of you has to buy or activate anything. What is not allowed: distributing or selling the Pro packages themselves as a standalone product or library, and building a competing product on them (§3.1).
Everything inside the client's perimeter
Nothing has to be ordered from a vendor: no SaaS, no licence server, and the system sends nothing out. The data lives in the client's database: PostgreSQL, SQL Server or SQLite. The client's security team reviews what it can see: NuGet packages, container images signed with cosign, and open source code. The closed Pro packages are not a black box either: we hand their source to companies for security review on request. For banks and public-sector clients this often settles the question before the pilot.
It works at size too: for example, one project has over 1M objects and over 47M property values.
Deployment: a module, not a release of the whole system
The client's routes live as modules in the redb.Tsak host. What the DevOps team, the client's or yours, gets:
- Three ways to ship the host. Ready Docker images (
redb-tsak-worker,redb-tsak-web,redb-tsak-stack), self-contained archives for Linux and Windows with no .NET install needed, or a host of your own built from NuGet in your pipeline:dotnet new tsak-workerfromredb.Tsak.Templatesgives a Worker Service onservices.AddTsak(configuration)with a Dockerfile. - Verifiable artifacts. Images and archives are signed with cosign, and the client's pipeline checks them with
cosign verifybefore deploying. - Storage to fit the job. SQLite by default: one server, nothing to install. PostgreSQL or SQL Server for a cluster.
- A module is one file. A
.tpkgpackage goes into themodules/folder or out withtsak module deploy. The host starts the new version, the old one finishes the messages it has started and stops, and the other modules on the node don't notice. Rollback istsak module rollback. - A hint for the pipeline. Before deploying, CI asks the node (
tsak system deploy-advice) whether the module can be swapped hot or needs the cold path, and gets the answer as an exit code any CI understands. - Kubernetes. Ready manifests, startup, live and ready probes, taking a node out of rotation (cordon) and back.
- Observability. A Prometheus endpoint, OpenTelemetry traces, a ready Grafana dashboard and a local Prometheus + Grafana + Jaeger stack in
docker compose. - API modes. Full, headless with no ports for embedding, or read-only for monitoring. Next to them, the
tsakCLI and a client package for your own tooling (services.AddTsakClient).
For a consultancy this means a change for a client is one module, not a release of the whole system with a night-time window.
The client sees what is going on by itself, without your developer: the dashboard shows every route with its traffic, errors and health.

It also has node monitoring: CPU, memory, threads and garbage collection, and next to it the list of modules, the scheduler, the log, the audit and the dead letters.

Signed modules: you build, the client deploys
A module can be signed. You create a key pair once (tsak module keygen), sign each module package in your CI (tsak module sign) and give the client the public key. The client's node with that key accepts only modules you signed: an unsigned or tampered package is refused. The client deploys updates itself, in its own Tsak, and you know for sure that it runs your build.
Ready items for a proposal
Some of what you usually have to promise as "we'll build it" is already there:
- Document exchange with Europe. The AS4 connector: version 4.6.1 passed the European Commission's conformance testing, 76 of 76 required tests, and redb.Route.As4 is on the list of eDelivery AS4 conformant products (Common Profile). For a client whose EU partner has written AS4 into the contract, that is a ready answer instead of a separate Java gateway in the estimate. Details in the AS4 article. AS2 is next to it for partners that use that.
- Integrations. 30 transport packages: Kafka, RabbitMQ, IBM MQ, SQL, HTTP, SOAP, SFTP, mail, cloud queues and more.
- Operations. The host dashboard: routes, errors, dead letters, the log, metrics, the cluster.

Several clients on one ecosystem means a separate database for each. There is no special "multi-tenant mode": isolation is by database, which is also easier to explain to a security team.
Honest limits
- Frequent releases. There is no long-term support branch. The current 4.7.x line gets fixes for critical defects and fixes on request; from 4.8.0 the packages target .NET 10 and 11 only. Plan updates into maintenance.
- Somebody runs the host. The server, the OS, TLS and database backups are the client's administrator's job, or yours if you sell it.
- Your own code stays yours. Business calculations and a connector that is not on the list are written in C#.
What I suggest
Don't move every client at once. Take one client and one integration that hurts today, build it on redb and compare the hours with the way you usually do it.
Code and documentation: github.com/redbase-app, articles: redbase.app/articles.
Which part of your projects repeats from client to client, and how many hours does it eat? Tell us in the comments.
If this was useful, a ⭐ on GitHub helps others find it.