π°π· νκ΅μ΄ν β Read this article in Korean: ν΅ν ν ν΅λ λμΉμ§ μλ λ² β Luwareκ° Akka.NET μ‘ν°λ‘ λ―Έμ ν¬λ¦¬ν°μ»¬ μμ± μλΉμ€λ₯Ό μ§ν¨ λ°©λ²
πΌοΈ Figure 0. (Hero) The actors holding up a mission-critical voice service β cartoon hero image

π― TL;DR β 3 lines
- Luware runs Nimbus, a Microsoft Teams-based contact center, handling millions of call minutes per month with zero downtime.
- Scattering call state across microservices led to distributed locking hell and race conditions β solved with **Akka.NET actors + cluster sharding + event sourcing**.
- The key mental shift: "one stateful object (an actor) owns one call in its entirety." The locks disappear, and the system "just works."
Imagine calling a contact center. Agent connection, queuing, transfers, recording, and call analytics all interlock at millisecond granularity. What happens if the timing slips just once? The call drops. The customer gets angry, and the business loses trust.
This is the world that Nimbus, built by the Swiss company Luware, lives in. Nimbus is contact center software integrated into Microsoft Teams, and it
Based on the Luware case study published by Petabridge, this article walks through the wall Luware hit and how they climbed over it with the **Akka.NET actor model** β explained at a working developer's eye level. If actors are new to you, don't worry: we build up the concepts step by step.
Initially, Luware managed call state across multiple stateless microservices. Information about a single call was scattered across service A, service B, and caches. That is exactly where the trouble began.
πΌοΈ Figure 1. Distributed locking hell vs. actors β the chaos of multiple services touching the same call state concurrently / the order of one actor owning a call outright

A quote from Luware engineer Jason Shave sums up the situation precisely: