App data resides in the place where it was created. Snapshots and data changes are persisted for resilience.
Distributing data and logic together
Fundamentally Unique
Our architectural first principles treat the app, not the database, as the system of record for data. This is our secret sauce that enables a better user experience, optimizes costs and security, and provides business flexibility.
First principles
Apps are in-mem DBs, recoverable and mobile
- Bundle transactional data and logic together to eliminate coherence risks
- Recover state through event sourcing
- Have location transparency for execution in environments close to end users
- Resilient without infrastructure HA
Apps have multiple read-write instances
- Increases throughput horizontally and optimizes efficiency
- Data is automatically sharded across instances
- Write instances replicate and converge modifications to data - like Google docs for your app’s data
Apps execute across hybrid environments
- Securely self-organize through masterless clustering
- Built-in split brain resolution
- Federate across hybrid cloud providers, regions, or data centers for cloud and data sovereignty
Limitless scaling
Akka apps are microservices that embed an Akka runtime that distributes data everywhere it needs to be. Scaling can be done in four dimensions to ensure elasticity and resilience:
1. Compute
2. Data
3. Servers
4. Regions
SCALE Up/Down Compute
Actors
- Location transparency
- Message passing
- Single threaded concurrency
Scale Data
Data Sharding & In-Mem Rebalancing
- Apps are in-mem DBs
- Data sharded across nodes
- Continual data re-sharding
Scale Out/In Servers
Masterless Clustering & Multi-RW Data
- Scale-to-zero rebalancing
- 0ms cold start
- Replicated R-W instances serving same data
Scale Across Regions
Active-Active Synchronization
- Continuous DR
- CRDT replication
- Traffic segregation
Akka Runtime
The industry’s first application runtime with Multi-Master Replication. All your app’s data, replicated everywhere your app runs, with conflict auto-resolution.
Replicate and migrate without downtime
Replication
Single Region, Pinned
For data sovereignty
Multi-Region, Replicated Read
For global HA
Operators pin a writable instance to a single region with read-only replicas in other regions.
Multi-Region, Replicated Write
For continuous, WAN-based DR
Writable instances in all regions with replicated changes.
Migrations
Start With One Place
Design, build and deploy apps within a single location.
Regional Migration
Add regions for apps to replicate across.
Custodial Migration
Retire an application in one place after movement to a second.Mix Akka-managed regions with self-managed.
Version & Schema Updates
Apps self-adapt to schema changes with end user traffic rerouting.
Infrastructure Upgrades
Promote read-only regions to writable for rolling infra updates.
Data handling for 10M + IOPS
Data Management Model
Akka apps share data and segregate queries for 10M+ IOPS. Akka applies dynamic computing with elastic operator controls for data, views, and queries.
Sharded Data
App data is automatically partitioned across in-memory nodes. Akka routes user requests to the correct instance.
Data Rebalancing
Data is re-partitioned into new shards as the number of runtime notes changes.
Query Elasticity
Transformed data queries are offloaded to separate compute. Operators scale data and query nodes separately.
Integration ready
Data Ecosystem Model
Your apps operate as a data ecosystem that do not require third party data integration tools.
Synchronize
For unreliable environments and digital twins.
Apps synchronize and rationalize their state with a peer instance without concern for data volume, sequence, or network connectivity.
Share
For advertising changes with interested peers.
Apps advertise and broadcast state changes over brokerless, reliable messaging that other apps can subscribe to.
Stream
For continuous real-time data processing.
Apps merge, map, transform, shift and calculate data in real time with a continuous operating model.
Synthesize
For transforming operational data into analytics.
Apps define projections which modify, push and propagate data changes into other Akka apps or 3rd party data systems, especially analytics warehouses.
Always recover
Akka apps can auto-recover by persisting state changes. Your app’s state changes are captured as replayable, sequential snapshots and events.
Proven patterns
Responsive by Design means we build with proven design patterns and use Reactive Principles. We bake them into your services and the Akka runtime so you don’t have to learn or implement them.
Separation of concerns
Joyful Inner Loop
Build aligned teams of delighted developers with an inner loop that abstracts domain logic from distributed dependencies.
Domain separation...
Keep your business logic yours. Build and test domain code like your first 'Hello, World' program. Akka's components inject intelligence at build with an inner loop that moves as fast as your fingers.
without, polluted domain logic
Decorating domain code or calling APIs to distribute data or improve resilience creates technical debt, cross-team friction, and coherence leaks.
Dev like a monolith. Deploy as m10e.
Chained Network Services
Your devs create & debug chained, networked services locally without dependency setup complexities. It’s like having the best of both worlds.
Single Service
Devs leverage their preferred IDE and build tools to create and test stateful services locally. Docker is the only runtime dependency!
Multiple Services
Teams work independently. Akka generates local sandboxes to test your service with its networked dependencies.
DevOps / GitOps Ready
Akka apps are packaged as Docker images and ready for rolling or canary deployments.
