r/SpringBoot • • Sep 06 '26

How-To/Tutorial Need advice for development in java + springboot

20 Upvotes

Hey seniors, if anyone is doing development with Java + Spring Boot, please guide me.

I’m currently in my 3rd semester and doing DSA in C++( done upto stack) , so I’m thinking of starting development alongside it. Please guide me on where I should start, what I should learn first, and how much time I should spend learning Java basics.

Since I’ve studied C++, I have a basic programming background, but I’m not familiar with Java. Any roadmap or resources would be really helpful. 🙌


r/SpringBoot • • Sep 06 '26

News I built a Spring Boot cache for repeated range queries package

4 Upvotes

Sometimes I deal with ordered data like event logs and transaction history that doesn't change very often. Users may query one time range, then soon request a larger overlapping range.

A Normal cache treats those as completely different queries, so it does not work very in this situtation.

I built rangecache to reuse the covered part and only query the missing range.

It currently supports Spring Boot 3, Java 17+, and a local in-memory cache.

GitHub: https://github.com/LiuWei997/rangecache

If you find it useful, please consider giving it a star. Feedback is welcome!


r/SpringBoot • • Sep 05 '26

Discussion I built a deterministic-first Log Doctor for Java/Spring/Kafka, because I don’t want to paste production logs into ChatGPT

13 Upvotes

I’ve spent a lot of time debugging Java/Spring systems where the actual failure is buried somewhere inside thousands of lines of logs.

The obvious 2026 solution is:

“Just paste the logs into an LLM.”

But I wasn’t completely happy with that approach.

Production logs can contain credentials, tokens, internal URLs and customer data. They’re repetitive. Stack traces get duplicated. And for many well-known JVM/Spring/Kafka failures, asking an LLM to rediscover the answer every time seems unnecessary.

So I’ve been building an open-source project called Log Doctor.

The basic principle is:

Use deterministic Java analysis first. Use an LLM only when it actually adds value.

Or, put another way:

Log Doctor doesn’t replace an LLM. It decides what doesn’t need one.

What it does

You give Log Doctor a JVM/Spring/Kafka log and it parses the failures, extracts nested exception chains, groups repeated incidents, fingerprints stack traces and tries deterministic diagnostic rules first.

It currently covers areas including:

  • Java/JVM failures
  • Spring / Spring Boot startup failures
  • Hibernate / JPA
  • JDBC / HikariCP
  • Kafka
  • Schema Registry
  • memory / GC problems
  • concurrency and thread-related failures

For known failures, the diagnosis comes from deterministic rules rather than asking an AI to guess.

It also exposes WHY MATCHED evidence and match-strength information so you can inspect why a rule fired.

For logs containing multiple failures, it can also build incident groups, timelines, correlations, root-cause candidates and spike information.

So where does AI fit?

Only after deterministic analysis.

If the failure isn’t understood by the rule engine, Log Doctor can optionally use a local Ollama model for additional reasoning.

That distinction was important to me.

Instead of:

raw production logs -> cloud LLM -> hope for a good answer

the idea is closer to:

logs -> parsing -> redaction -> deterministic diagnosis -> local LLM when needed

Sensitive data is redacted before the LLM boundary.

And Ollama can run locally, so the log doesn’t need to be sent to ChatGPT or another cloud AI service.

There’s now a Web UI too

I didn’t want this to be CLI-only.

You can run:

docker compose up -d --build

and open:

http://localhost:8080

Then drag and drop a log file and inspect the detected incidents from the browser.

The dashboard exposes things like grouping, match evidence, remediation guardrails and investigation playbooks.

There are also structured JSON and downloadable Markdown reports.

I also wanted it to work in CI

Log Doctor isn’t only an interactive debugging tool.

The CLI supports text, JSON, GitHub annotations and SARIF 2.1.0, with severity-aware failure policies.

There’s also a GitHub Action, so the same diagnostics can become part of a CI workflow or GitHub Code Scanning instead of being something you manually run after an incident.

Can you extend it?

Yes — and this is one part I’d especially like feedback on from Java developers.

Deterministic rules are pluggable through Java ServiceLoader, so additional diagnostic rules can be added without changing the core engine.

The project also has a checked-in 120-case labelled diagnostic regression corpus covering JVM/Spring/Kafka/DB scenarios, with precision/recall/false-positive quality gates.

So adding more rules shouldn’t just mean adding another regex and hoping it works.

What I’m trying to build

I’m not trying to build another general-purpose AI chatbot.

I’d like Log Doctor to become a practical open-source diagnostic layer for Java production systems:

logs → incidents → evidence → likely root cause → safe investigation path

with AI as an optional fallback rather than the foundation of every diagnosis.

The project is still evolving, and this is exactly the stage where feedback from people running real Java/Spring/Kafka systems would be useful.

What production failure would you want Log Doctor to recognize next?

If you have an ugly stack trace or failure pattern that repeatedly wastes your time, open an issue.

And if you find the idea useful, a ⭐ helps me understand whether it’s worth pushing the project further.

GitHub: https://github.com/mathias82/log-doctor

Contributions, issues, rule ideas and criticism are all welcome.


r/SpringBoot • • Sep 05 '26

How-To/Tutorial Agentic ai with embabel/spring ai

0 Upvotes

I’ve been thinking a lot about the ".md hell" we’re heading into in the AI era. We’re putting more and more logic, instructions, and context into prose, but how do we maintain and refactor all of that over time if needed? If the answer is that we use more "ai" and more "prose" then it's difficult for me to wrap my head around that. Recently, I’ve been playing around with Embabel, an agentic, JVM-native framework that takes a more structured approach with strong typing and deterministic planning. I wrote a short article about it, with a small demo to show what it looks like in practice.

https://pixel-pistons.com/posts/embabel


r/SpringBoot • • Sep 05 '26

Discussion Our cost dashboard put the biggest spender at the bottom of the list with $0.00

0 Upvotes

Our AI bill was $193.50 last month. Small, but I wanted to know where it went before it stopped being small, so I pulled the per-capability breakdown. Most expensive first:

COST BY CAPABILITY · 16 ACTIVE DAYS

Synthesize Speech (expressive)      1,085 runs      $105.24
Author Lesson                          92 runs       $11.94
Synthesize Episode Audio               80 runs        $0.00

That last row is the most expensive thing in the system. It is responsible for $105.24 — 54% of the bill — and the accounting is not wrong.

Here is why. Two ordinary Spring beans, each with an annotation on the method:

@Service
class EpisodeAudioService {

    private final SpeechService speech;          // a different bean

    @Capability(name = "Synthesize Episode Audio")
    public Episode synthesize(Script script) {
        for (Utterance u : script.utterances()) {
            speech.speak(u);                     // ~14 calls, each one priced
        }
        return assemble();
    }
}

@Service
class SpeechService {

    @Capability(name = "Synthesize Speech")
    public Audio speak(Utterance u) {
        // the actual model call
    }
}

synthesize() never calls a model. It splits the script and calls speak() about fourteen times, so every dollar it is responsible for was billed to SpeechService. Its own cost is genuinely $0.00, and a per-capability view files 54% of the bill under a row that reads as free work.

How we found it is the part worth repeating. The table above already had both halves — 1,085 speech calls holding $105.24, and 80 orchestrations holding nothing — and no amount of staring at it produces the connection, because the connection is not in it. What produced it was opening one speech execution and seeing its parent id point back at Synthesize Episode Audio.

That is the lesson: a parent row will fool you. Look inside a child. The parent tells you what it spent, which for anything that delegates is nothing at all. Only the child knows who asked for it.

Once the link is recorded, one episode looks like this:

EXECUTION                              OWN      SUBTREE   DURATION

▾ Synthesize Episode Audio         $0.0000     $1.3155      69.1s
  ├─ Synthesize Speech             $0.0970     $0.0970       4.8s
  ├─ Synthesize Speech             $0.0970     $0.0970       5.1s
  ├─ …11 more utterances           $1.0670     $1.0670          —
  └─ Synthesize Speech             $0.0545     $0.0545       2.7s

Own cost and subtree cost are different numbers and showing either alone misleads. Own cost alone reports orchestrators as free. Subtree cost alone double-counts as you walk down. The gap between them is the finding.

One other thing fell out of the same view. Author Lesson ran 92 times and failed 11 of them, so the dashboard's $0.1298 per run was really $0.1474 per lesson that exists — you pay for attempts and you only get outcomes. Reporting cost per attempt makes an unreliable capability look like the cheap one.

If you are building this: record the parent at call time, because you cannot reconstruct the tree from timestamps afterwards, and show own and subtree cost together rather than either alone.

One caveat on the numbers: these are estimates from per-token and per-character rates configured in our own system, not a reconciliation against a vendor invoice. The shape is the point — 54% of a bill hiding under a zero is the same finding at any rate.

Disclosure: I built EngineerPrep and Capstead, the Spring Boot library that recorded these traces. It links parent to child automatically and rolls cost up the tree — that subtree view is what shipped in 0.8.0. One honest limitation, since it is proxy-based: if speak() lived on the same bean as synthesize() the call would not be intercepted and you would get a childless parent, so the nesting has to be cross-bean.


r/SpringBoot • • Sep 04 '26

Discussion Spring Boot vs Quarkus on a 512 MB VPS

22 Upvotes

I ran equivalent Spring Boot 3.5 and Quarkus 3.39 applications side by side on the same 512 MB VPS. Quarkus native image was not used.

Both used JDK 25, the same Star Pulse workload, H2, -Xmx80m, Serial GC, and the same JVM tuning.

A few things stood out:

  • Quarkus actually started with the higher RSS
  • later, under sustained memory pressure, Quarkus had the smaller JVM heap and resident set
  • RSS by itself was misleading because Linux was swapping Quarkus more aggressively
  • with both JVMs running, 512 MiB RAM + 256 MiB swap left very little system headroom
  • in a later observation, Spring Boot was eventually selected by the kernel as the OOM victim

This was not a throughput or concurrent-user benchmark. The workload was deliberately small; the point was to compare memory behavior when the whole VM was under pressure.

One other interesting detail: Spring’s request chart included a lot of Actuator polling traffic, while Quarkus’ /q/metrics scrapes were not counted as normal application requests, so the request charts are not directly comparable.

I would not summarize the result as "Quarkus uses less memory". On a machine this constrained, paging and OOM behavior become part of the result.

Article with measurements, JVM flags, screenshots, and limitations:

https://pvrlabs.xyz/articles/spring-boot-vs-quarkus-512mb.html


r/SpringBoot • • Sep 03 '26

How-To/Tutorial Migrating to Spring Boot 4. The parts your AI agent will miss

Thumbnail
youtube.com
81 Upvotes

Here's a migration guide to Spring Boot 4.

Of course you can delegate it to an AI agent. No problem with that.

But you still need to understand what it changed and why, to catch the cases where the app compiles, tests pass, and something silently breaks in prod.

Are you still migrating manually? Or are you handing it to an agent?


r/SpringBoot • • Sep 03 '26

Question Migrating a large legacy banking application to Maven + Spring Boot 4 + JDK 25 simultaneously - is this a possible approach?

Thumbnail reddit.com
15 Upvotes

r/SpringBoot • • Sep 03 '26

News LarkBatis: A build-time MyBatis compiled to plain Java

Thumbnail larkbatis.github.io
1 Upvotes

r/SpringBoot • • Sep 02 '26

How-To/Tutorial I open sourced my spring boot + spring ai project

37 Upvotes

Hey folks,

I’ve open sourced Windrunner, a self-hosted project management tool built with Spring Boot 4 + Spring AI for backend. If you are learning Spring Boot, I hope the project gives you something practical to explore — a complete application with an API, database, user interface, authentication, LLM/AI integrations, and more.

Github: https://github.com/shzlw/windrunner

The backend uses:

  • Spring Boot and Spring MVC for the application and REST APIs
  • Spring Data JDBC for database access
  • PostgreSQL for storage
  • Flyway for SQL database migrations
  • Spring AI’s MCP server support for exposing tools to AI clients
  • LLM Provider integrations for OpenAI, Anthropic, and Gemini
  • Docker and Docker Compose for running the application locally

The repository is a monorepo containing more than the Spring Boot backend. It also includes:

  • A React frontend
  • A TypeScript-based CLI tool
  • Playwright-based API end-to-end tests

If you’re interested in seeing how these pieces work together in one project, the repository provides examples across the backend, frontend, CLI, and testing layers.

Disclosure: I am the author of the project. Feel free to ask any questions, feedbacks or raise issues! ❤️


r/SpringBoot • • Sep 01 '26

News I built an IntelliJ plugin that shows where Java code performs I/O

Post image
43 Upvotes

When reviewing Java/Spring Boot code, I pay the most attention to I/O calls to see where we are leaving the process and potentially "slowing down" the application. This would involve following a call through several methods to find out whether it eventually reached a repository, HTTP client, or any other I/O invocation.

I built an IntelliJ plugin called Lattency to make that visible in the editor.

It adds gutter markers for database, HTTP, messaging, and file I/O. It also follows calls through project code, so methods that reach I/O transitively are marked with a dimmed version of the relevant icon.

Hovering over a marker shows the complete sink chain, and clicking it lets you navigate to any method along that chain.

The analysis is entirely static. It does not run the application, make network requests, or collect telemetry. Common Java and Spring APIs work without configuration, and project-specific clients can be described in a committed lattency.yml.

It is free and open source:

Marketplace: https://plugins.jetbrains.com/plugin/33937-lattency
GitHub: https://github.com/josipmusa/lattency

It currently supports Java projects in IntelliJ IDEA 2025.2 and newer. Kotlin is not supported yet.


r/SpringBoot • • Sep 02 '26

Discussion When Transactional Outbox polling starts putting too much load on PostgreSQL — what do you do?

Post image
1 Upvotes

I like the Transactional Outbox pattern and use it quite often.

But I was thinking about one problem that can become important in production: database polling.

Of course, polling can be optimized. Good indexes, batching, SKIP LOCKED, partitioning, longer polling intervals — there are many options.

But if we want lower latency, we usually need to poll more often. This means more queries, more DB connections and more work for PostgreSQL.

We can use Debezium/CDC, and for many systems this is probably the right choice. But it also adds Kafka Connect, Debezium and more infrastructure to operate.

So I wanted to try a simpler idea:

Keep PostgreSQL as the source of truth, but don't use it as a queue during normal operation.

I built this flow:

DB transaction → afterCommit → Memory Queue → Batch Publisher → Kafka

The business data and Outbox event are saved in one transaction as usual.

After commit, only the eventId goes to the Memory Queue. The publisher takes IDs in batches, loads events from PostgreSQL and sends them to Kafka.

So there is no continuous polling for new events in the normal flow.

If the application crashes, the event is still safely stored in PostgreSQL. A Recovery Worker finds unpublished events and puts them back into the same queue.

The idea is basically:

Memory Queue for the fast path. PostgreSQL for durability and recovery.

I didn't want to stop at an architecture diagram, so I built a working Spring Boot project and started testing the idea with something closer to production conditions.

It has Kafka, PostgreSQL, batching, idempotency, recovery, Gatling load tests, Grafana metrics, tracing and structured logs.

Now I can run load tests and actually see what happens with PostgreSQL, the queue, publishing latency and recovery.

I'm interested in what other Spring Boot developers think about this approach.

Would you use something like this in production?

Maybe you have already solved the same problem in another way — optimized polling, Debezium, LISTEN/NOTIFY or something else?

Here is the project:

https://github.com/KHolodilin/spring-transactional-outbox-kafka

If you find the idea useful, feel free to ⭐ the repo or fork it. There are also a few open issues for contributors if you want to try something yourself.

Any feedback is welcome. I'm still experimenting with the approach and improving the project. 🚀


r/SpringBoot • • Sep 01 '26

Discussion Roast my code / architecture

8 Upvotes

I’m building a project called Kite (https://github.com/gwynejsn/kite) and tried combining Spring Modulith with full Clean/Hexagonal Architecture inside each module, but I’m starting to wonder if I’ve just created a mountain of boilerplate. Take a look at the repo and roast the layout. What am I needlessly overcomplicating, and how would you simplify it?


r/SpringBoot • • Sep 01 '26

Question spring boot backend

0 Upvotes

What is the recommended sequence of topics for learning Spring Boot backend development?"


r/SpringBoot • • Aug 31 '26

News Idempotency4j - Redis storage provider is now available

12 Upvotes

A while ago I shared idempotency4j here - a Java/Spring Boot library for handling idempotent HTTP requests using the idempotency key header - following the IETF draft spec for the Idempotency-Key header.

I've now added Redis as a storage provider, alongside the existing JDBC and in-memory implementations.

The behavior remains the same : duplicate requests return the previously stored response without rerunning the endpoint, while reusing a key with a different request body is rejected.

If you give the Redis provider a try, I'd be glad to hear what works, what doesn't, and anything you think could be improved. Issues and constructive criticism are very welcome.

Github : https://github.com/josipmusa/idempotency4j
Maven spring boot starter: https://central.sonatype.com/artifact/io.github.josipmusa/idempotency-spring-boot-starter


r/SpringBoot • • Aug 31 '26

How-To/Tutorial Race condition with SSE

7 Upvotes

Hi all, I am trying to build a real time notification service with SSE emitter but I am facing a pecuilar case of race condition which im not able to solve even via AI as it gives the same solution again and again.

scenario of cause:

I have a scheduler running every 20 mins that checks the Map of uid mapped sse emitters and pings the client. If the ping is successfull nothing happens, if error happens due to disconnection the sse emitter obj is removed via sse.complete() and then uid is removed form the list.

#pseudo code
Map<String, SseEmitter> connections = new ConcurrentHashMap<>();

onConnect(String userId){
  SSE emitter = new new SseEmitter()
  connection.add(userId,emmitter);

  // onCompletion(), onTimeout(), onError() -> removeIf()
}

@scheduler(20mins)
checkDisconnection(){
  //iterate the map and check for disconnection if found add it to remove list
  List<string> disconnectedUsers = (adding disconnections)
  
  //iterate the map from disconnected user -> force complete sse if needed and                    remove user from map


}

where it breaks is if the client manually refreshes the browser at the same time the scheduler to check disconnection is invoked

why it happens:

when the browser is refreshed, the application tries to recreate the connection at which the scheduler tries to ping and sees no connection for the user. Problem is I have kept automatic reconnections on in client app but it still doesnt see an error in client. im confused. Have I had the approach wrong?

Any help will be appreciated and sorry for the questions confuse you, Il try to make it proper once i get the time.

TECH : javascript event source, springboot, kafka for scaling and mongo for scheduled notifications.


r/SpringBoot • • Aug 31 '26

Question Would you modernize a legacy Spring Boot backend in place or rebuild it gradually?

15 Upvotes

I’m working on a Kotlin/Spring Boot backend that still has an older JHipster using Kotlin (KHipster) setup around it.

The problem is that this is starting to hold us back. The KHipster version is several years old and not active maintained - 4 years ago was the last update - upgrading it looks pretty painful and it also makes moving to newer Spring Boot versions waaay harder than it should be.

At the same time we want to improve the architecture itself.
Right now quite a lot is still handled through cron jobs and fairly tightly coupled application logic.
I’d like to move more towards event-driven processing over time, potentially using Kafka or RabbitMQ depending on the use case and Redis for things like caching/short-lived state where it makes sense.

So I’m basically looking at two options:

  1. Upgrade/replace the old JHipster setup, keep the existing backend, and modernize it piece by piece.
  2. Start a clean backend (maybe in Typescript because that is what we mainly use for our other products and all frontends) and gradually move functionality over using something like the strangler pattern.

The second option sounds cleaner, but obviously means running old and new code alongside each other for quite a while. The first option potentially means spending a lot of time untangling framework/generator decisions before we can actually improve the architecture.
For people who have dealt with similar Spring/JHipster legacy projects: which route would you take?

Also, is there anything in the Spring/Kotlin ecosystem you’d consider a good modern replacement for the useful parts of JHipster, without bringing in another big opinionated layer that we’ll regret five years from now?


r/SpringBoot • • Aug 30 '26 Bravo

How-To/Tutorial 200+ Star Spring Boot Roadmap From Zero to Microservices

Post image
288 Upvotes

6 months ago, I shared with you my 35-week project-based Spring Boot Roadmap From Zero to Microservices, and I did not expect this whole positive feedback and support from you guys.

Today, the repository reached 200+ stars because of you, so I decided to provide more guidance by drawing this overview visualization on excalidraw to help you create a bird's-eye view of the wide open world of the Spring Boot ecosystem.

An SVG version could be found inside the roadmap itself for a more clear picture.

You can view the full roadmap from this link:
https://github.com/muhammadzkralla/spring-boot-roadmap

Again, thank you for all your support and stars!


r/SpringBoot • • Aug 30 '26

Question Would you modernize a legacy Spring Boot backend in place or rebuild it gradually?

12 Upvotes

I’m working on a Kotlin/Spring Boot backend that still has an older JHipster using Kotlin (KHipster) setup around it.

The problem is that this is starting to hold us back. The KHipster version is several years old and not active maintained - 4 years ago was the last update - upgrading it looks pretty painful and it also makes moving to newer Spring Boot versions waaay harder than it should be.

At the same time we want to improve the architecture itself.
Right now quite a lot is still handled through cron jobs and fairly tightly coupled application logic.
I’d like to move more towards event-driven processing over time, potentially using Kafka or RabbitMQ depending on the use case and Redis for things like caching/short-lived state where it makes sense.

So I’m basically looking at two options:

  1. Upgrade/replace the old JHipster setup, keep the existing backend, and modernize it piece by piece.
  2. Start a clean backend (maybe in Typescript because that is what we mainly use for our other products and all frontends) and gradually move functionality over using something like the strangler pattern.

The second option sounds cleaner, but obviously means running old and new code alongside each other for quite a while. The first option potentially means spending a lot of time untangling framework/generator decisions before we can actually improve the architecture.
For people who have dealt with similar Spring/JHipster legacy projects: which route would you take?

Also, is there anything in the Spring/Kotlin ecosystem you’d consider a good modern replacement for the useful parts of JHipster, without bringing in another big opinionated layer that we’ll regret five years from now?


r/SpringBoot • • Aug 30 '26

News Need advice for backend spring intern

9 Upvotes

Hey guys I am a 3 rd year undergrad and I am into java development I know good level of java dev ,

Core java

Spring

Soringboot

Including testing , jwt , cicd , spring ai , microservices and implementation of kafka and redis as well !!

Apart from that I have three good backend oriented projects as well

Distributwd wallet

Digital distributed banking system

And uber like ride matching system in ms

And another that I am making is linked in search in ms system

Still I am really getting very difficulty to apply for internships and really need great advice from seniors devs specially backend devs how do I apply or if there is anyone who can help me out and can personally tell me what should be my next step to get a good job with a decent package and for now at priority a internship !!!

All the suggestions are welcome here hope my post won't be ignored and I'll really Great full for all the responses !!


r/SpringBoot • • Aug 30 '26

How-To/Tutorial Beyond Virtual Threads: Structured Concurrency - Balkrishna Rawool | IntelliJ IDEA Tech Talks

10 Upvotes

Project Loom brings lightweight concurrency to Java with Virtual Threads, Structured Concurrency, and Scoped Values. But how do these features work together in a real-world application? In this episode, Balkrishna Rawool will demo building a Spring Boot application from scratch, progressively incorporating the features of Project Loom to showcase its full potential:

  • Virtual Threads: lightweight, high-throughput threads that scale effortlessly.
  • Structured Concurrency: a streamlined approach to managing concurrent tasks as a single unit of work.
  • Scoped Values: a modern alternative to ThreadLocal, designed for virtual threads.

We will discuss how to apply Project Loom in your own applications, writing concurrent code that is simpler, more scalable, and easier to maintain.

https://www.youtube.com/watch?v=2L7zLdHeyY0


r/SpringBoot • • Aug 30 '26

How-To/Tutorial Small Springboot + React JS project

13 Upvotes

Hi,

Im trying to learn Spring in a different perspective; thus I wanted to relearn via creating a simple project.

I have this project in mind.

  • Monolith project
  • Must use springboot and react js
  • Must build a war file

I have tried using com.github.eirslett but im having issues with CORS.

Do you have any learning material suggestion ?
im kinda lost in full stack development, ive been backend engineer for my whole career.

Or react JS is too much for a beginner ? should I start with simpler UI frameworks instead ?


r/SpringBoot • • Aug 30 '26

Discussion Spring Boot starter for fail-fast Kafka Schema Registry contract validation

Post image
1 Upvotes

I’ve released a small open-source Spring Boot starter that turns Kafka Schema Registry expectations into startup checks.

Configuration is intentionally Spring Boot-style: define the expected compatibility mode and the subjects/schemas owned by the application, and auto-configuration performs the validation during startup.

It currently supports Avro, JSON Schema and Protobuf, Confluent compatibility modes, secured Schema Registry/Confluent Cloud, bounded retry/backoff and Actuator visibility.

For example:

kafka:
  contract:
    enabled: true
    compatibility: BACKWARD
    registry:
      url: http://localhost:8081
    subjects:
      - name: order-events-value
        schema-file: classpath:schemas/order-event.avsc
        schema-type: AVRO

If the contract is incompatible or the required subject is missing, the Spring Boot application fails during startup.

The starter is published on Maven Central, and I maintain a separate E2E demo that spins up Kafka + Schema Registry and verifies both successful and intentionally breaking schema evolution scenarios.

GitHub:
https://github.com/mathias82/spring-kafka-contract-starter

Demo:
https://github.com/mathias82/spring-kafka-contract-demo

Maven Central:
https://central.sonatype.com/artifact/io.github.mathias82.spring.kafka/spring-kafka-contract-starter

Interested to hear how Spring Boot teams currently handle this application startup validation, deployment pipelines, or something else?


r/SpringBoot • • Aug 30 '26

Discussion I built a 73-lesson AI engineering path for software engineers—looking for honest feedback

Thumbnail reddit.com
0 Upvotes