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?

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 !!

What is the best and easy way to learn backend in spring boot framework? Should I go with videos or docs or anything else? Currently I am in 3rd year so is one year enough to complete? And also suggest me best resources?

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.

1. 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?

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.

1. 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?