soda-core 17.0.0 · Apache Maven Central

soda

Simple · Object-Oriented · Domain-Driven · Architecture

Enterprise DDD and CQRS for Spring Boot.
Made simple, on purpose.

A clean four-layer architecture, CQRS, and event-driven design — in one starter. Generate a project and ship.

17.0.0 · one jar Java 17+ Spring Boot 3.2 – 4.1 MIT licensed
What's in the name

Four letters. One architecture

SODA is not another framework. It's a way of building Spring Boot software that stays legible as it grows.

S

Simple

Low ceremony, low learning curve. The DDD pieces you need — nothing you don't.

O

Object-Oriented

Encapsulation and clear ownership. Models are modeled the OO way.

D

Domain-Driven

The domain comes first: aggregates, entities, domain events, ubiquitous language.

A

Architecture

Four layers with strict boundaries — so every file has exactly one home.

CQRS inside

Commands and queries speak different languages — on purpose. Write-side rules stay in the domain; reads stay fast.

In the AI era

Good architecture is AI's guardrail

Clear boundaries — so you can let AI write freely

🧱

One job per layer

Dependency direction is fixed, and every change has exactly one home. Code AI adds lands in the layer it belongs in — nowhere to stray.

📘

Ships with an AI manual

Every generated project ships with a CLAUDE.md — layer duties, naming conventions, the full checklist for adding an endpoint. AI reads it once and knows the drill.

🎯

One sentence, the whole set

Say “add an order query endpoint” and AI produces the Query, Handler, Repository and Assembler — right files, right names, right places.

~/my-soda-project/CLAUDE.md
## Scenario A · add a read-only endpoint

Step 1 domain model + repository
  1  XxxDetail.java            domain/{domain}/
  2  XxxData.java              domain/{domain}/
  3  ListXxxQuery.java         application/cqrs/command/query/
  4  XxxReadRepository.java    infrastructure/repository/{domain}/

Step 2 API layer
  5  XxxVO.java                application/{domain}/model/vo/
  6  XxxAssembler.java         infrastructure/assembler/
  7  ListXxxQueryHandler.java  application/cqrs/handler/query/
  8  XxxAppService + Impl      application/{domain}/service/

You just say what you want.

The shape of a SODA project

Four layers. Strict boundaries

Generated for you on day one — and enforced ever after.

Adapterinbound / outbound
REST ControllersAdviceDTO / VO
Applicationuse-case orchestration
CommandsQueriesHandlers
Domainbusiness core
Aggregate RootsEntitiesDomain Events
Infrastructuretechnical details
RepositoriesACLAssemblers
Why teams pick soda

Boring where it should be

⚡

Simple to learn

DDD and CQRS without the academic overhead. New contributors productive in days.

🚀

Fast queries

Read models tuned for query speed, write models keep the business rules — CQRS lets each side do its own job.

💾

Efficient storage

Sensible persistence patterns. No event-store tax unless you opt in.

🔍

Easy to debug

Clear data paths and one home per class. When it breaks, you know where to look.

Compared to Axon

The right amount of framework

sodaAxon
Learning curve● simple●● moderate
Event sourcingextensiblefull support
Storage efficiency● efficient●● needs care
Query performance● fast●● needs care
Debugging● straightforward●● moderate
AI-assisted development● CLAUDE.md built in○ none
Three minutes

From zero to a running project

STEP 01

Generate

Pick a template on the generator — single module or cloud-ready multi-module.

STEP 02

Build

mvn package — H2 in-memory by default, zero external deps.

STEP 03

Run

Boot it, hit the sample API — the four layers are already wired.

~/my-soda-project
$ mvn package
$ java -jar target/my-soda-project.jar
…
$ curl localhost:8080/check
ok

Your next Spring Boot project,
structured right

Generate it in the browser. Own the code forever.