{"slug": "from-closed-internal-stack-to-open-source-ecosystem-i-finally-shipped-three-of", "title": "From Closed Internal Stack to Open-Source Ecosystem: I Finally Shipped Three Years of .NET Infrastructure", "summary": "The article describes RedBase, an open-source .NET ecosystem developed over three years to eliminate repetitive infrastructure work in .NET projects. It replaces traditional data layers, integrations, authentication, and runtime plumbing with four integrated pillars: a schema-less object storage engine (redb), a routing and integration framework (redb-route), a production runtime container (redb-tsak), and an OAuth/OIDC identity server (redb.Identity). The author reports that one business workflow requiring approximately 3,000 hours using traditional methods took only about 128 hours with RedBase, attributing the efficiency gain to the elimination of \"seams\" between system layers.", "body_md": "*This is a submission for the\nGitHub Finish-Up-A-Thon Challenge*\n\n## Why this exists (the actual pain)\n\nBefore the architecture talk, the *why*. Three years ago\n\nI watched my team — and every other .NET team I knew —\n\nburn most of their hours not on business logic but on\n\nplumbing the same four layers over and over:\n\n-\n**EF Core + migrations.**`DbContext`\n\n, fluent mappings, navigation properties, N+1 puzzles, lazy/eager loading, a migration per field, separate read/write models if you go CQRS. On a non-trivial object graph that's hundreds of hours just for the data layer, before any business logic is written. -\n**A pile of integration connectors.** Kafka here, RabbitMQ there, S3 for files, SFTP for the legacy partner, an HTTP webhook for the new one, each one hand-rolled with its own retry policy, dead-letter, idempotency, serialization, health check, telemetry. Ten integrations × 40-80 hours each. -\n**Auth.** OAuth flows, refresh tokens, scope checking, claims transformation, multi-tenant, M2M, DPoP if you want to be modern — built from`IdentityServer`\n\n/`Auth0`\n\n/`Keycloak`\n\nplus 200-600 hours of glue per serious deployment. -\n**Runtime.** Hot-reload without dropping in-flight messages, graceful drain on redeploy, cluster coordination, leader election, watchdog, dashboard — usually missing entirely on .NET, or assembled from 5-7 unrelated NuGets that don't share conventions.\n\nThe worst part isn't any single layer — it's the **seams\nbetween them**. Where the auth user becomes the EF entity\n\nbecomes the Kafka message becomes the S3 blob, every seam\n\nis one more serialization, one more mapping, one more\n\nversioning headache, one more place a 3 AM page comes from.\n\nRedBase is built so that **business code is the only thing\nleft to write**. The class IS the schema (no EF, no\n\nmigrations). The 22 transports share one DSL (no per-connector\n\nplumbing). Identity is a\n\n`direct-vm://`\n\nRoute (calling authis calling a function, not a network round-trip). Tsak gives\n\nyou hot-reload, cluster, dashboard, drain out of the box. The\n\nseams collapse because everything lives on the same fabric.\n\nOn the one full business workflow where I had honest before/after\n\nnumbers — built the traditional way vs built on the RedBase\n\nstack — the human effort was **roughly ~3,000 hours vs ~128\nhours**. That ratio isn't magic on any single layer (where\n\neach subsystem gives 3-5× at most); it comes from the seams\n\nno longer existing. When I asked Claude Opus 4.7 to\n\nsanity-check that estimate against typical .NET project\n\nbreakdowns (data layer + integrations + auth + runtime +\n\ninter-seam testing), the order of magnitude held up.\n\nOne stack, one team, one architectural style — so the team\n\ngets to write features instead of wiring infrastructure.\n\n**That** is the project. Everything below is just how I got\n\nthere.\n\n## What I Built\n\n**RedBase** — a four-pillar open-source ecosystem for .NET\n\nthat grew up inside one production system over three years\n\nand finally got shipped to the world this spring. Three\n\npillars are now public on GitHub under Apache 2.0, and the\n\nfourth is in pre-release polish:\n\n**1. redb** — typed\n\nobject storage engine. Your C# class IS the schema. Two\n\nphysical tables (\n\n`_objects`\n\n+ `_values`\n\n), full LINQ, zeromigrations, recursive-CTE tree queries, bulk\n\n`COPY BINARY`\n\nsaves on PostgreSQL and\n\n`SqlBulkCopy`\n\non SQL Server. Freecore + Pro tier with tree-diff ChangeTracking saves.\n\n**2. redb-route**\n\n— Apache Camel for .NET. Fluent C# DSL for\n\n`From → Process → To`\n\npipelines, **22 transport packages**\n\n(Kafka, RabbitMQ, MQTT, S3, gRPC, SFTP, AMQP, Azure\n\nService Bus, IBM MQ, Elasticsearch, Redis, LDAP, FTP, HTTP,\n\nWebSocket, SignalR, Firebase, TCP, Mail, SQL, Quartz,\n\ngeneric File),\n\n**80+ EIP patterns**(Splitter, Aggregator,\n\nCBR, Circuit Breaker, Saga, ...), compiled expression\n\nengine, transactional routes, OpenTelemetry built-in.\n\n**3. redb-tsak**\n\n— the .NET analogue of Apache Karaf / Camel K. Production\n\nruntime container: drop a\n\n`.tpkg`\n\nbundle (ZIP with`manifest.json`\n\n+ entry-point DLLs + dependency DLLs +per-module JSON config) — or just a bare\n\n`.dll`\n\nfor thesimplest cases — into\n\n`Libs/`\n\n, get hot-reload withoutdropping in-flight messages, REST + Blazor dashboard,\n\nwatchdog, Quartz scheduler, three deployment modes\n\n(Standalone / Single-node+redb / Cluster with leader\n\nelection & auto-rebalance), per-module\n\n`AssemblyLoadContext`\n\nisolation, API Key + HMAC-SHA256security, 30-command CLI, typed C# client.\n\n**415+ tests.**\n\n**4. redb.Identity** *(pre-release, repo opening soon)* —\n\nOAuth 2.1 / OIDC server, architecturally transport-agnostic:\n\nevery endpoint is a `direct-vm://`\n\nRoute. That gives two\n\nready usage modes today: **(a) in-process** — call the\n\nauth server directly from another module in the same\n\nrun-time with zero network hop, zero serialization, zero\n\nHTTP stack (this is what `direct-vm://`\n\n*is*), and\n\n**(b) HTTP** — a full OAuth 2.1 / OIDC HTTP facade is\n\nshipped and working. The other RPC-capable facades —\n\ngRPC, RabbitMQ RPC, AMQP request/reply, IBM MQ\n\nrequest/reply, WebSocket, SignalR, TCP — are on the\n\nroadmap and become near-trivial to add because the core\n\nlogic is already wire-format independent. (The\n\nfire-and-forget transports in the Route set — Kafka\n\nproducer, File, S3, Mail, etc. — don't fit an auth\n\nserver, so they're correctly out of scope.) OpenIddict\n\nunder the hood, REDB-backed storage, DPoP / PAR / Dynamic\n\nClient Registration / SCIM 2.0 / FIDO2 / WebAuthn /\n\nRFC 8417 shared-signals support.\n\n**1751+ tests** passing before public release.\n\nTotal scope: **~385k LOC** (326k C# + 58k SQL) across\n\n~2200 source files, **Apache 2.0**, NuGet-published, all\n\ndocs at [redbase.app/why-redbase](https://redbase.app/why-redbase).\n\n## Demo\n\n**Live docs and positioning:**\n\n-\n[redbase.app/why-redbase](https://redbase.app/why-redbase)— full \"Sound familiar?\" pain-point walkthrough with side-by-side Traditional-vs-RedBase code examples - The docs site itself is powered by RedBase — every page, example, and API reference is a REDB object in MSSQL. We eat our own cooking.\n\n**Published article series on dev.to**\n\n([author page](https://dev.to/rinat_kozin_d0a2ef43e7824)) —\n\nthe ecosystem is too large for one post, so I'm publishing\n\na deep-dive series, one pillar at a time:\n\n-\n*May 13*—[We built an enterprise integration stack for .NET from scratch: EAV + DSL + runtime](https://dev.to/rinat_kozin_d0a2ef43e7824/we-built-an-enterprise-integration-stack-for-net-from-scratch-eav-dsl-runtime-2l16)— overview of the whole stack -\n*May 14*—[I spent a year building Apache Camel for .NET. Here's the honest state of it.](https://dev.to/rinat_kozin_d0a2ef43e7824/i-spent-a-year-building-apache-camel-for-net-heres-the-honest-state-of-it-150e)— discussion piece, what's done / what isn't -\n*May 17*—[redb.Route — Apache Camel for .NET: 22 transports, 30+ EIP patterns, compiled DSL](https://dev.to/rinat_kozin_d0a2ef43e7824/redbroute-apache-camel-for-net-22-transports-30-eip-patterns-compiled-dsl-11m0)— integration framework deep dive -\n*May 21*—[An EF Core alternative for .NET apps with complex object graphs — full LINQ, no migrations, no DbContext](https://dev.to/rinat_kozin_d0a2ef43e7824/two-tables-zero-migrations-full-linq-a-net-data-engine-thats-been-running-our-production-for-2482)— REDB storage engine deep dive (this is the one that already triggered the multi-version-deploy thread referenced below)\n\n…and the series continues. Tsak (runtime container,\n\nhot-reload, cluster, watchdog) gets its own post next,\n\nthen Identity (transport-agnostic OAuth 2.1 / OIDC) when\n\nthe repo opens, then a deep dive on the tree-diff\n\nChangeTracking path, then a multi-DB benchmark post.\n\nA stack this size is a genuinely hard engineering\n\nproblem to explain — trying to cram it into one article\n\nwould lie about the depth. So I'm taking it one layer\n\nat a time.\n\n**The 30-second flavor:**\n\n```\n// 1. Define schema — no migration needed\n[RedbScheme(\"order\")]\npublic class OrderProps\n{\n    public Customer Customer { get; set; }\n    public Address ShippingAddress { get; set; }\n    public List<OrderLineProps> Lines { get; set; } = [];\n    public Dictionary<string, RedbObject<CouponProps>> Coupons { get; set; }\n}\n\n// 2. Save entire object graph in one call\nawait redb.SaveAsync(order);\n\n// 3. Query with full LINQ over nested props\nvar hot = await redb.Query<OrderProps>()\n    .Where(o => o.Customer.Address.City == \"London\"\n             && o.Lines.Any(l => l.Qty > 10))\n    .OrderByDescending(o => o.DateModify)\n    .Take(50)\n    .ToListAsync();\n\n// 4. Tree query with recursive CTE under the hood\nvar allProducts = await redb\n    .TreeQuery<Product>(londonHQ.Id, maxDepth: 10)\n    .Where(p => p.InStock)\n    .ToListAsync();\n// Same dev defines a routing context with redb.Route.\n// Real production patterns: REDB isn't a transport URI —\n// it's accessed inside processors via DI (.ProcessWithRedb).\npublic class OrdersRouteBuilder : RouteBuilderBase\n{\n    public override void Build()\n    {\n        From(\"kafka://orders-raw\")\n            .Unmarshal<OrderProps>()\n            .Split(o => o.Lines, EipParallel.Yes)\n            .ProcessWithRedb(async (redb, exchange, ct) =>\n            {\n                var line = (OrderLineProps)exchange.In.Body;\n                await redb.SaveAsync(line);   // REDB store\n            })\n            .Aggregate(by: e => e.In.Headers[\"OrderId\"],\n                       timeout: 5.Seconds())\n            .To(\"rabbitmq://orders-enriched\");\n\n        // Staged queue with backpressure — exactly how the\n        // production garage-sync route does it:\n        From(\"seda://orders?concurrentConsumers=4\")\n            .ProcessWithRedb(EnrichFromInventoryAsync)\n            .To(\"http://partner-api/orders\");\n    }\n}\n\n// Pack as a .tpkg bundle (manifest.json + entry-point DLL\n// + dependency DLLs + module config.json) — or for trivial\n// modules, just drop the bare .dll — into Libs/ of a Tsak\n// node. Tsak picks it up, runs it across the cluster,\n// rebalances on node failure, drains old versions on hot\n// redeploy.\n//\n// Need the same flow gated by an OAuth scope?\n// Two ready modes today:\n//   * in-process — the call goes through direct-vm://\n//     straight into redb.Identity, no network, no HTTP;\n//   * over HTTP — standard OAuth 2.1 / OIDC endpoints.\n// Tomorrow, the same auth server can also be exposed over\n// any other RPC-capable Route transport (gRPC, RabbitMQ\n// RPC, AMQP request/reply, IBM MQ, WebSocket, SignalR,\n// TCP, ...) as those facades land — no change to the\n// auth server itself:\n//\n//     .Process(ctx => ctx.RequireScope(\"orders.write\"))\n```\n\nThat last paragraph — \"drops a `.tpkg`\n\n(or just a `.dll`\n\n),\n\ngets hot-reload + cluster + dashboard + REST API + drain on\n\nredeploy + an auth server callable from the same routing\n\nfabric\" — is the part I'm proudest of, because it's exactly\n\nthe piece\n\nthat's been missing from the .NET integration story for a\n\ndecade. Java had Karaf, Camel K, and a mature OIDC story\n\nglued together. .NET had nothing equivalent that wasn't\n\neither vendor-locked or hand-rolled per project.\n\n## The Comeback Story\n\n**Before (early 2026):** all four pillars existed and\n\nworked. Years of work. Real production load — 3-node\n\ncluster, ~550 internal users at a HoReCa distributor,\n\n~500k business objects, ~15M `_values`\n\nrows, three months\n\nrunning every operational integration in the company.\n\nAnd yet:\n\n-\n**0 public repos.** Everything in a closed monorepo. -\n**0 NuGet packages.** Even our own internal services built it from source. -\n**0 published docs.** A 14-line`README.md`\n\nin each project. \"TODO: document this properly\" in two of them. -\n**0 external users.** Nobody outside the company even knew it existed. -\n**0 stars, 0 issues, 0 community.** The classic \"we'll open-source it when it's ready\" trap — except it had been \"ready enough for production\" for over a year and \"ready to share\" still felt one polish-pass away every quarter.\n\nThe honest version: I was scared. ~385k LOC of opinionated\n\narchitecture decisions, exposed to public criticism, with\n\nmy real name on it. Easier to keep shipping it inside a\n\ncontract than to put it on the internet.\n\n**After (May 2026):**\n\n-\n**3 public GitHub repos** under[github.com/redbase-app](https://github.com/redbase-app):`redb`\n\n,`redb-route`\n\n,`redb-tsak`\n\n. Apache 2.0. CI, badges, real READMEs. The fourth (`redb-identity`\n\n) is in final polish — 1751+ tests green, repo opens before the contest deadline. -\n**43 NuGet packages published**(`redb.Core`\n\n,`redb.Postgres`\n\n,`redb.Route.Kafka`\n\n,`redb.Tsak.CLI`\n\n, ...) with**~18k cumulative downloads**, the bulk of that (~15k) added in the active-launch window over the last ~10 days, on a clean upward curve day over day. External developers can`dotnet add package`\n\ntoday. Early signal:`redb.Route`\n\n(the integration framework) has already overtaken`redb.Core`\n\nin download count — 1497 vs 1482 — meaning the \"Apache Camel for .NET\" positioning is landing, not just the storage story. Inside Route,`redb.Route.Http`\n\nis the fastest-growing transport — confirming the hypothesis that HTTP is the natural first entry-point for new users exploring the DSL. -\n**Marketing/docs site live** at[redbase.app](https://redbase.app)— quick start, architecture page, pricing, full API docs. The site itself runs on REDB to prove the engine handles real content load. -\n**A 4-post dev.to series** already out (May 13 → May 21), with more deep dives queued. The REDB-storage post is already getting sharp technical questions in comments — including one about multi-version rolling deploys that surfaced a genuinely unsafe default in`SyncStructuresFromTypeAsync`\n\n(`strictDeleteExtra = true`\n\n) that I'd never noticed in three years of production use because we always single-version-deploy in our internal workflow. That defect went straight onto the fix list — exactly the kind of feedback that justifies open-sourcing in the first place. -\n**First reactions and shares from the broader .NET community.** Validation that the niche is real.\n\nThe completion arc isn't \"I wrote a thing.\" The arc is\n\n\"I had a thing that worked for years inside one company\n\nand I finally let it leave the building.\" Different muscle\n\nentirely. Documentation, positioning, choosing what to call\n\nit (RedBase / REDB / redb — we picked one and renamed\n\neverything), writing READMEs for repos that had no audience\n\nfor years, recording first impressions, drafting tweets,\n\nanswering the first technical comment in public.\n\nThat last one is the hardest part of shipping. The code\n\nwas done. Letting it be judged was the work.\n\n## My Experience with GitHub Copilot\n\nHonest framing first: a large part of this codebase is my\n\nown work, written before Copilot was a serious factor.\n\nThe architectural decisions, the storage model, the\n\ntwo-table layout, the tree-diff save strategy, the\n\n`direct-vm://`\n\ntransport-agnostic routing fabric that lets\n\n`redb.Identity`\n\nbe called in-process today with zero\n\nnetwork hop *and* exposed over HTTP today *and* grow\n\nadditional facades over the RPC-capable Route transports\n\n(gRPC, RabbitMQ RPC, AMQP, IBM MQ, WebSocket, SignalR,\n\nTCP, ...) tomorrow — all without touching the auth server\n\nitself — all of that came from years of sitting, thinking,\n\nprototyping, and throwing prototypes away. No AI invented\n\nthose.\n\nWhat Copilot changed was the *finishing arc*. The codebase\n\nhad the right shape, but it also had:\n\n- features sketched-in but not closed out;\n- helper layers half-typed because \"I'll do this properly later\";\n- XML doc-comments missing on 80% of public surfaces;\n- READMEs with\n`TODO: document this`\n\n; - corner cases I knew existed and had been deferring;\n- six different naming conventions across four years of rewrites that nobody had unified.\n\nCopilot is what let me finally close all of that out\n\nwithout burning a year of evenings.\n\n**Where it was a real force multiplier:**\n\n**Finishing deferred features.** Pieces I had on a\n\nmental backlog for months — round-trip serialization\n\nedge cases, missing operators on the LINQ provider,\n\nTsak CLI commands I'd been meaning to add, missing\n\ntransport options in`redb.Route`\n\n— Copilot let me\n\nknock them out in evenings instead of weekends because\n\nit could read the surrounding code, infer the\n\nconvention, and propose an implementation that I then\n\nreviewed and corrected. The decisions stayed mine.\n\nThe typing speed and the \"what was I about to do here\"\n\nrecovery time collapsed.**Structuring code I already had.** A lot of the work\n\nwasn't writing new logic — it was taking working but\n\nmessy code, splitting it into the right files,\n\nextracting the right interfaces, renaming things\n\nconsistently across ~2200 files. Copilot is excellent\n\nat that kind of mechanical-but-context-sensitive\n\nrefactor where you need to keep semantics intact while\n\nmoving things around.**Comments and XML documentation at scale.** Adding\n\n`/// <summary>`\n\nto thousands of public members with\n\naccurate descriptions of what each method actually\n\ndoes — by hand this is a multi-week slog and you'll\n\ngive up after two days. With Copilot reading the\n\nimplementation and proposing the comment, then me\n\ncorrecting where it was wrong, it became a steady\n\nbackground task that actually finished.**Documentation and READMEs.**~12 projects, each\n\nneeding a consistent voice, accurate API examples,\n\ncorrect cross-references, and a quick-start that\n\nactually runs. With Copilot it became \"draft → review\n\n→ correct → ship\" instead of \"stare at empty file →\n\nprocrastinate.\" Same for the redbase.app positioning\n\npages — the \"Sound familiar? / WITH REDBASE\" pattern\n\nyou see on the site got drafted in one afternoon and\n\nthen iterated.**Cross-file architectural navigation while debugging.**\n\nThe`redb.Core.Pro`\n\nChangeTracking save path crosses\n\n`ValueTreeBuilder`\n\n,`ValueTreeDiff`\n\n,\n\n`ProObjectStorageProviderBase`\n\n, and the SQL bulk-ops\n\nlayer. Holding all four files in working memory\n\nsimultaneously while chasing a deduplication bug in\n\narray hash updates — Copilot did the \"where is this\n\ncalled from, what's the contract\" lookup, my brain did\n\nthe fix.**Honest fact-checking before publishing.** I once\n\nasked it to draft a reply claiming \"old readers ignore\n\nunknown structures gracefully on multi-version deploys.\"\n\nIt pushed back, we read the actual code together, and\n\nthe answer turned out to be \"reads are graceful, writes\n\nare destructive, and the production playbook\n\ncompensates with runtime drain.\" That nuance got\n\npublished. The first version would have been a small\n\nlie. Same loop surfaced the`strictDeleteExtra = true`\n\ndefault that's been on the fix list ever since.**RFC-driven implementation (this one mattered a lot**\n\nfor Identity).`redb.Identity`\n\nis built almost\n\nentirely on top of public RFCs: OAuth 2.1 / 6749,\n\nToken Revocation 7009, Introspection 7662, Dynamic\n\nClient Registration 7591 / 7592, JWK Thumbprint 7638,\n\nSCIM 7644, OAuth for Native Apps 8252, Device\n\nAuthorization 8628, Token Exchange 8693, DPoP 9449,\n\nShared Signals 8417 — and that's not the full list.\n\nFor a solo developer, staying strictly compliant with\n\nthat many specs is*brutal*: every endpoint has\n\n\"MUST / SHOULD / MAY\" clauses scattered across multiple\n\n§-sections of multiple documents, edge cases like\n\n\"what status code on revoke of unknown token\" (7009\n\n§2.1: still 200), \"must DPoP-Nonce rotate on every\n\nbearing response\" (9449 §8: yes), \"is`dpop_jkt`\n\nbinding\n\nenforced at the token endpoint\" (9449 §10.1: yes) \\u2014\n\nmiss one and you've shipped a non-compliant auth\n\nserver. Copilot was constantly the \"wait, RFC 7591 §3.2.1\n\nsays the response MUST include a registration access\n\ntoken, did you cover that?\" voice in the room. The\n\ntest suite reflects that: 1751+ tests with explicit\n\n`\"RFC XXXX §Y.Z: ...\"`\n\nassertion messages, written\n\nin the loop of*\"I remember the spirit of this clause,*Without that, achieving real RFC\n\nCopilot, pull up the exact wording and let's make a\n\ntest out of it.\"\n\ncompliance solo would have been a multi-year sub-project\n\non its own.\n\n**The pattern that emerged:** I came in with the design\n\nand most of the code already in place. Copilot saw what\n\nwas there, understood the conventions, and helped me\n\n*finish*. Polish XML docs. Close out deferred TODOs.\n\nWrite the documentation pages. Refactor the inconsistent\n\nbits. Catch the contradictions before they hit a public\n\ncomment thread. That's a different relationship than\n\n\"AI wrote my project.\" It's closer to having a very\n\nfast pair-programmer who actually read the codebase\n\nbefore sitting down.\n\n**Honest summary:** ~385k LOC of infrastructure in three\n\nyears of part-time work was the human heroic effort.\n\n*Finishing* it — closing out the deferred features,\n\nfilling in all the missing comments and documentation,\n\nunifying the naming, writing the READMEs, shipping the\n\nNuGet packages, drafting the dev.to articles, answering\n\nthe first hard comment in public — that's where Copilot\n\ncollapsed months into weeks. The contest prompt is\n\n\"revive and finish a project you started but never\n\ncompleted.\" My project wasn't unfinished in design.\n\nIt was unfinished in *all the small, deferred, boring,\nnecessary things* that turn a working codebase into a\n\nshippable product. Copilot is what made that finishing\n\narc actually fit inside one spring.\n\n## What's next (already in flight, not on a wish-list)\n\nShipping the four pillars wasn't the finish line — it was\n\nthe *beginning* of the public phase. Three big bets are\n\nalready underway, in source, in this repo:\n\n**Free engine is overtaking Pro.** The\n\n[docs/FreePvtQuery](//../FreePvtQuery/FREE-OVER-PRO.md)\n\ninitiative is rewriting the REDB query path on top of\n\nPostgreSQL PVT functions, and the free tier is already\n\n*ahead*of Pro on a long list of features:\n\n`$case`\n\n/`$coalesce`\n\n/`$cast`\n\n/ n-ary`$concat`\n\nin\n\nprojections, full regex predicates (`$regex`\n\n,\n\n`$iregex`\n\n,`$regexReplace`\n\n), extended math\n\n(`$power`\n\n,`$sqrt`\n\n,`$log`\n\n,`$sin/cos/tan`\n\n, ...),\n\nextended string ops (`$substring`\n\n,`$replace`\n\n,\n\n`$indexOf`\n\n,`$padLeft/Right`\n\n), projection-level\n\n`DISTINCT ON`\n\n, date-extract in`Select`\n\n, and as of\n\n2026-05-23 —`HAVING`\n\nfor both regular and array\n\n`GroupBy`\n\n(33/33 integration tests green across PG\n\nFree + PG Pro + MSSql Pro). Net effect: most of what\n\nused to be Pro-only is becoming free, and the\n\nfree engine is gaining capabilities Pro doesn't have\n\nat all.**REDB outside C#.** The whole point of building the\n\nquery layer as language-neutral JSON AST evaluated by\n\ndatabase-side PVT functions is that*the C# LINQ*. The same\n\nprovider is just one front-end`_objects`\n\n+\n\n`_values`\n\nstorage, the same scheme registry, the same\n\nquery AST can be driven from Python, from Google Apps\n\nScript, from any language that can speak Postgres or\n\nMSSQL — without porting the engine. That unlocks REDB\n\nas a shared object store across heterogeneous stacks,\n\nnot just .NET shops. Architecturally, the work is\n\nalready done: every query goes through JSON AST →\n\nPVT functions, no C#-side filter compilation required\n\nfor the heavy path.**Route keeps growing.** New transport connectors are\n\non the roadmap, deep-dive articles for the Tsak\n\nruntime container and for`redb.Identity`\n\nare queued\n\nup after the contest deadline, and the EIP catalogue\n\nis being expanded incrementally on top of the\n\nexisting 80+ patterns. The fastest-growing transport\n\n(`redb.Route.Http`\n\n) is also driving a focused docs\n\npass on the HTTP path specifically.\n\nThe honest version: the ecosystem has been moving for\n\nyears and barely anyone outside one production deployment\n\nknew. The potential is genuinely large — language-neutral\n\nobject storage with a full EIP runtime *and* a compliant\n\nidentity server on top of the same fabric is not a thing\n\nthat currently exists on .NET. That's the bet I'm\n\nfinishing.\n\n**Team:** solo submission. All commits, all docs, all\n\narticles by one author with Copilot in the loop.\n\n**Live in production:** 3-node cluster, ~550 internal\n\nusers, ~500k objects, ~15M `_values`\n\nrows, ~2500 hours\n\nuptime, zero data-layer incidents in 3 months.\n\n**Stack:** .NET 8 / 9, PostgreSQL 17, MS SQL 2022,\n\nBlazor Server, Quartz.NET, Npgsql, OpenIddict,\n\nOpenTelemetry.\n\n**License:** Apache 2.0 across all four pillars.", "url": "https://wpnews.pro/news/from-closed-internal-stack-to-open-source-ecosystem-i-finally-shipped-three-of", "canonical_source": "https://dev.to/rinat_kozin_d0a2ef43e7824/from-closed-internal-stack-to-open-source-ecosystem-i-finally-shipped-three-years-of-net-4lcf", "published_at": "2026-05-23 16:07:54+00:00", "updated_at": "2026-05-23 16:32:52.364223+00:00", "lang": "en", "topics": ["open-source", "developer-tools", "enterprise-software", "data", "products"], "entities": ["RedBase", "IdentityServer", "Auth0", "Keycloak", "Kafka", "S3", "EF", "CQRS"], "alternates": {"html": "https://wpnews.pro/news/from-closed-internal-stack-to-open-source-ecosystem-i-finally-shipped-three-of", "markdown": "https://wpnews.pro/news/from-closed-internal-stack-to-open-source-ecosystem-i-finally-shipped-three-of.md", "text": "https://wpnews.pro/news/from-closed-internal-stack-to-open-source-ecosystem-i-finally-shipped-three-of.txt", "jsonld": "https://wpnews.pro/news/from-closed-internal-stack-to-open-source-ecosystem-i-finally-shipped-three-of.jsonld"}}