Welcome to the introduction of our “Building with Akka” series, where we introduce the fundamentals of distributed applications using the Akka platform. This article serves as an introduction to the concepts that will guide us in building a Customer Registry Application. To explore the complete series, use the navigation buttons at the bottom of this page.

In today’s interconnected world, distributed applications have become the backbone of modern computing infrastructure. These systems, which run across multiple computers in a network rather than on a single machine, power everything from the social media platforms we use daily to critical financial systems and cloud computing services.

Distributed applications are fundamentally challenging to build and maintain. They must handle network partitions, manage consistency across physically separated components, and gracefully degrade when parts of the system fail. Unlike traditional monolithic applications, there’s no central point of control, making debugging, monitoring, and ensuring system correctness significantly more complex.

Distributed applications with Akka

In this context, Akka has been well known as a powerful set of libraries that bring the elegance of the Actor Model to the JVM ecosystem. At its heart, actors serve as the fundamental units of computation that communicate through asynchronous message passing. This elegantly simple approach eliminates the need for low-level thread management and helps prevent common concurrency issues like deadlocks and race conditions. 

Thousands of companies and projects have used Akka to deliver concurrency, amazing performance, scalability, and resilience. We and many others have found that apps built with Akka ‘just worked’ and dev teams were able to focus on logic rather than backend system coding. 

However, there was a steep learning curve for many users. While many apps could benefit from using the libraries, some teams could not justify the learning curve. With the recent release of the Akka 3 – officially known as the Akka platform – that’s all changed. The Akka platform is built on the libraries, but it has abstracted away tons of complexity and you don’t even have to learn or mess with actors. Here at Scalac, we’re excited because we can use the Akka platform to help many more customers develop innovative apps even faster than before. 

What is the Akka platform?

The reimagined Akka has been announced in a blog post by Jonas Bonér, founder of Akka (formerly Lightbend). Akka is described as a platform for building and running responsive applications:

• a new SDK is provided
• a Platform as a Service (PaaS) is now available at console.akka.io

In other words, Akka has evolved into a comprehensive platform while maintaining its core OSS libraries, such as akka-actor, akka-stream, akka-http, akka-persistence, etc. In particular, it introduces three major components:

• a new SDK featuring high-level components, local development tools, and composable elements that significantly reduce the learning curve from weeks to hours;
• multiple deployment options: Serverless (pay-as-you-go), Bring Your Own Cloud (BYOC), and upcoming Self-Hosted deployment in 2025;
• enhanced cloud operations with flexible deployment models including single-region and multi-region configurations, plus zero-downtime management capabilities.

Does the Akka SDK replace the Akka libraries?

No. The Akka SDK is built on top of the Akka libraries. Whether to choose the former or the latter depends on your need. The Akka libraries and SDK offer contrasting approaches to building distributed systems, but whatever your choice, apps can interoperate.

The Akka SDK takes an opinionated approach by implementing specific guardrails and patterns, making it simpler and faster to build elastic and resilient applications. Within a day’s training, developers can create services that handle up to one million TPS (transactions per second).

By contrast, the Akka libraries are not opinionated – they don’t dictate how developers should design distributed systems. Instead, they provide maximum flexibility and control, allowing teams to fully customize their system’s behavior and configuration. We believe most projects can be executed with the new Akka SDK.

Purpose and motivation

The next series of posts aims to present a comprehensive example which runs on the Akka platform. The implementation we’ll explore comes directly from the Akka team, while the article’s structure is inspired from the Shopping cart quickstart guide.

We’ll present a customer registry application built with the newest feature of Akka. This is an overview of the next parts:

• Section 1: Project setup
• Section 2: Domain model and Entity
• Section 3: Views and APIs
• Section 4: Deployment

We assume that you are already familiar with Reactive Architectures and the principles spelled out in the Reactive Manifesto. They cover concepts, such as:

• responsive, resilient, and elastic features;
• asynchronous communications;
• event sourcing and CQRS;
• sharding and replication.

If you are not familiar with these concepts, we recommend the free series of courses of the Akkademy, Reactive Architecture – Principles and practices for designing reactive systems.

Prerequisites

Before starting, make sure you set up the following tools and software:

• An Akka account
• Akka CLI
• Java 21 (we recommend Eclipse Adoptium/Temurin)
• Apache Maven
• Docker Engine
• curl command-line tool

All right! Let’s start by downloading and setting up our project!

This concludes our introduction to distributed applications with Akka. In the next part of our “Building with Akka” series, we’ll begin setting up our Customer Registry Application. Click the “Next” button below to continue the journey.