Petabridge: Beyond HTTP

Building a Distributed Job Scheduler with Akka.NET

hi@petabridge.com — Fri, 31 Jul 2026 14:00:00 +0000

18 minutes to read

Imagine your business has to execute long-running jobs that can take anywhere from a few minutes to tens of hours to execute. You want to scale horizontally on-demand in order to parallelize job execution - Akka.NET is a perfect technology for that!

We want to:

Distribute jobs evenly across an arbitrary number of workers;
Recover mid-flight jobs in the event of worker death;
Have our job scheduler / coordinator survive restarts and crashes; and
Support scaling the system horizontally (adding new nodes) without interrupting or rebalancing jobs that are already in-progress.

We built an open source proof of concept work distribution platform for one of our Akka.NET Support customers who has this design challenge in their domain. Here’s what the dashboard looks like:

How does it work and how can it apply to your business too?

Click here to read the full article.

Introducing Netclaw: An Always-On, Autonomous Agent Built on Akka.NET

hi@petabridge.com — Mon, 06 Jul 2026 15:00:00 +0000

14 minutes to read

I’ve been wanting to write this post every single day for about six weeks now, and I finally get to: we shipped a brand new open source project called Netclaw.

Netclaw is an always-on, autonomous personal assistant built on top of large language models and Akka.NET. It runs quietly in the background, connects to the chat applications you already use, and handles the endless little tedious tasks that eat into your day. It’s deliberately simple and predictable, it takes security seriously, and it works just as well with a small model on your own hardware as it does with a big hosted one.

We covered a bit of the “how we built it” story on a recent Akka.NET Community Standup, but this post is the proper introduction: what Netclaw is, why we built it the way we did, and what you can actually do with it today.

Click here to read the full article.

Visualize Your Akka.Streams Graphs with OpenTelemetry

hi@petabridge.com — Thu, 18 Jun 2026 14:00:00 +0000

8 minutes to read

Register one OpenTelemetry source and your traces will show the real shape of your Akka.Streams graph: every stage, in the order it actually runs. No commercial license, no extra wiring. It’s built into Akka.NET as of v1.5.66.

People have been asking us for this since 2021. This post and its accompanying video walk through why it took so long, how we built it, and what it looks like running against a real production app.

Click here to read the full article.

Why We Removed FluentAssertions from Akka.NET

hi@petabridge.com — Wed, 10 Jun 2026 19:12:12 +0000

11 minutes to read

Back at the very end of March we shipped Akka.NET v1.5.64. We’ve done a handful of releases since then, but I want to come back to this one specifically, because it contained a change that’s been a long time coming: we removed FluentAssertions as a dependency from every Akka.NET TestKit package.

If you write tests against Akka.NET, this might be a breaking change for you. So let me walk through exactly what changed, why we did it, and what you should do about it.

Click here to read the full article.

Case Study: Luware Building Mission-Critical Voice Services with Akka.NET

hi@petabridge.com — Wed, 13 May 2026 15:00:00 +0000

12 minutes to read

Every so often a customer comes along whose use case is so demanding that it validates every design decision you’ve ever made in the framework. Luware is that customer for us.

Jason Shave is an Engineering Manager at Luware, where he leads a team of developers working on Nimbus, contact center software that integrates with Microsoft Teams. Luware handles millions of calling minutes per month, serves over 1,000 customers worldwide, and operates 24/7 with zero tolerance for downtime. When I sat down with Jason, I wanted to understand why he picked Akka.NET, how his team uses it, and what the results have looked like in production.

What follows is that conversation.

Click here to read the full article.

Managing Long-Running Tasks Inside Akka.NET Actors

hi@petabridge.com — Mon, 13 Apr 2026 14:00:00 +0000

19 minutes to read

Here’s a scenario we hit all the time on TextForge: a new user signs up, connects their Gmail account, and now we have to pull down their entire mailbox history. For the pro plan, that can be hundreds of thousands of emails. Which translates to tens of thousands of Gmail API round trips, exponential backoff when the API pushes back, intermittent network failures, and tens of minutes (sometimes longer) of continuous work per user. And on top of that, we need to be able to cancel the job cleanly, because the pod hosting that actor might get rebalanced across the cluster, or we might roll a deployment, or the user might disconnect the account mid-sync.

So the question is: how can a single Akka.NET actor manage a long-running background job without becoming non-responsive to its own mailbox?

This post (and its accompanying video) walks through the exact pattern we use in TextForge’s MailboxSyncActor: a CancellationTokenSource field, a fire-and-forget PipeTo, and a couple of subtle lifecycle details that will bite you if you skip them.

Click here to read the full article.

How AI Will Transform Open Source Business Models

hi@petabridge.com — Wed, 14 Jan 2026 13:01:01 +0000

15 minutes to read

This is Part 2 of a two-part series. Part 1 covered why AI is accelerating open source adoption, not killing it. This post examines which business models thrive and which struggle in the AI era. Subscribe to our mailing list if you haven’t already.

In Part 1, I argued that AI isn’t killing open source - it’s amplifying adoption at unprecedented rates. Akka.NET’s 35% year-over-year download growth in 2025, combined with industry-wide metrics showing 70-87% growth across major package registries, proves that LLMs are recommending and adopting libraries faster than humans ever could.

But there’s a second story buried in the Tailwind CSS saga that deserves its own analysis: AI isn’t killing open source - it’s disrupting specific types of open source businesses.

Adam Wathan captured this perfectly in his GitHub comment:

“Tailwind is growing faster than it ever has and is bigger than it ever has been, and our revenue is down close to 80%.”

Read that again. The framework is thriving. The business is struggling. This isn’t a contradiction - it’s the clearest illustration of where AI is creating winners and losers in the open source economy.

Let me break down what’s actually happening, using both Tailwind’s situation and our own experience at Petabridge as a counter-example.

Click here to read the full article.

AI Won't Kill Open Source - It Will Amplify It

hi@petabridge.com — Thu, 08 Jan 2026 19:31:22 +0000

19 minutes to read

Earlier this week, Adam Wathan, the creator of Tailwind CSS, dropped a bombshell about how AI has impacted his company and its employees:

the reality is that 75% of the people on our engineering team lost their jobs here yesterday because of the brutal impact AI has had on our business. And every second I spend trying to do fun free things for the community like this is a second I’m not spending trying to turn the business around and make sure the people who are still here are getting their paychecks every month.

The reaction was swift and predictable. Hot takes flooded in declaring the death of open source, the end of OSS sustainability, and the AI apocalypse that would render libraries and frameworks obsolete. Geoffrey Huntley captured the prevailing narrative perfectly¹:

“AI can generate code, bypassing the need to deal with open-source woes… I’ve found myself using less open source these days… This shift challenges the role of open-source ecosystems.”

I had a tweet about the Tailwind situation go viral and there were dozens of quote tweets and comments echoing the very same. “AI eats open source” is easy to find in abundance online.

Here’s the problem: everyone is getting this perfectly backwards.

AI isn’t killing open source. It’s amplifying it to unprecedented levels. The Tailwind situation isn’t about declining OSS adoption - it’s about a business model that was working great in a world where learning curves were high and documentation was the bottleneck. That world is gone, and the revenue model built on top of it is collapsing. But the underlying Tailwind library? It’s thriving.

Let me show you why the doomsayers are wrong, backed by actual data from our own experience...

Click here to read the full article.

Migrating from CRUD to CQRS and Event-Sourcing with Akka.Persistence

hi@petabridge.com — Tue, 30 Dec 2025 18:00:00 +0000

15 minutes to read

We’re about a year into the process of completely re-working Sdkbin to better support our needs here at Petabridge and, eventually, other third-party software vendors.

Sdkbin was originally built on an extremely flimsy CRUD architecture that violates most of my personal design preferences - you can read about the history behind that here. But to summarize, I tend to use the following heuristics when building software:

Prefer optionality-preserving designs - make sure your design decisions can be reversed or altered when things inevitably change.
Use as few moving parts as possible - most of Akka.NET is constructed this way.
No magic - if nothing magically works, then nothing magically breaks either.
Ensure that coupling happens only where it’s necessary - coupling usually needs to happen in your integration layer (i.e. your UI or HTTP API.) Your accounting system should probably not be coupled to your payments system.

Sdkbin’s original CRUD design violated all of these principles:

Used hard deletes, destroying data with no ability to recover or audit (impossible to reverse);
Relied heavily on AutoMapper-powered generic repositories (magic with lots of moving parts); and
Was highly coupled throughout - Stripe payment events served double-duty as invoices, for instance.

We’ve fixed a ton of these issues already, and one of the most important tools we’re using is Akka.Persistence. We’ve also made some significant improvements to Akka.Persistence in recent releases that made it much easier for us to accomplish our ambitious goals with Sdkbin.

Let me show you what we did.

Click here to read the full article.

The Worst Security Vulnerability in Akka.NET - And How to Fix It

hi@petabridge.com — Wed, 26 Nov 2025 18:00:00 +0000

15 minutes to read

In October 2025, we disclosed the most critical security vulnerability ever found in Akka.NET: CVE-2025-61778. This vulnerability affects Akka.Remote’s TLS implementation - specifically, we were supposed to implement mutual TLS (mTLS), but we didn’t. The server never validated client certificates, meaning anyone who could reach your Akka.Remote endpoint could potentially join your cluster without any authentication.

The immediate action you should take: upgrade to Akka.NET v1.5.56 or later. The vulnerability has been fully patched in these versions.

In this post, we’ll cover the nature of this vulnerability, who was affected, how we fixed it, and - most importantly - security best practices for securing your Akka.NET applications going forward.

This vulnerability was discovered by one of our Production Support customers during a security audit. Within 2-3 weeks of being notified, we shipped four patches (v1.5.52 through v1.5.56) to address the issue. This is exactly the kind of critical response our support customers receive - and the entire Akka.NET community benefits from their vigilance.

Click here to read the full article.