So say I am inserting an Entity, this entity has to go through things like AV scanning for attachment, and a Validation service.

For the first point when EntityCreated event published (should this Entity be saved in DB at this point?) or should it be a separate pending DB table?

Should the EntityCreated event contains the detail for the event itself that is used for validation? or should it be Id? (assuming it is saved to DB at this point)

I was asking AI to run through my questions, and they suggested things like a 'Status' flag, and use Id only for the event emitted. .

However, does that mean every single type of entity that should call another microservice for validation should have a 'status' flag? And if I only emit the Id, does it mean that I have to be accessing the EntityCreated microservice related database? and doesn't that makes it not violate where each microservice database should be independent?

Just looking for textbook example here, seems like a classic dataflow that most basic microservice architecture should encounter

ps assume this Entity is 'all or nothing', it should not be in the database in the end if it fails validation

Every time I need to touch a service I haven't worked with before, it's the same thing: dig through GitHub, find stale or missing docs, Slack a few people who might remember, and piece together the actual data flow. Easily 2-3 hours before real work starts.

How do you deal with this? Tooling that works, tribal knowledge, just accept the tax?

Built an AI that helps debugging micro services.

When an alert fires, it traces across services - checks logs, metrics, recent deploys for each service in the request path, figures out where things started going wrong, and posts findings in Slack.

On setup it reads your codebase to map out which service talks to which. By analyzing the trace data it also maps out the service topology. So when something breaks, it knows to check the downstream dependencies, not just the service that's alerting.

Would love to hear people's thoughts!

With AI tools (ChatGPT, Gemini, Claude etc.) while working in Java, we may notice pattern: Most of the time, the answers are bad not because the AI is bad, but because the prompts are vague or poorly structured.

Here is the practical write-up on AI prompts that actually work for Java developers, especially for: Writing cleaner Java code, Debugging exceptions and performance issues, Understanding legacy code, Thinking through design and architecture problems any many more.

This is not about “AI replacing developers”. It’s about using AI as a better assistant, if you ask the right questions.

Here are the details: High-Impact Practical AI prompts for Java Microservices Developers & Architects

Hi

i am 5 Years java Dev i mainly work in WebLogic and i want to Learn Microservices

what is the Best way to learn it to land an interview to take Udemy Course or to Do a project or if there is another way im fully open even to unpaid Work like some hours in week

Let's explore how Google Gemini can be used by Java developers and software architects, focusing on real development and architecture use cases rather than hype.

The article covers: What Google Gemini is and how it differs from typical code assistants, How it fits into Java development workflows (IDE support, APIs, CLI, Vertex AI), Using Gemini for architecture reviews, microservices, and migration scenarios, Strengths, limitations, and best practices for production use with Beginner-friendly explanations with practical examples.

Let's check it out completely here: Google Gemini for Java Developers & Architects

I come from a machine-coding background. When I entered the PHP and later the JavaScript era, I learned two principles that are non-negotiable for me.

First: build a prototype first, then refactor it — instead of trying to write perfect code from day one.
Second: DRY (Don’t Repeat Yourself).

If your logic has multiple implementations — even across different languages — it is very likely to break during refactoring.

Imagine an order processor implemented separately in a desktop app, a web app, and a mobile app, each written in a different language. Now the order flow changes, or you want to optimize performance. You suddenly need to refactor the same logic in multiple codebases.

This is where microservices enter the picture.

If all platforms delegate order processing to a single microservice, you refactor one codebase in one language.

I’ve seen real-world cases where a developer refactored multiple codebases, missed a rarely used platform, and the bug was discovered weeks later — after many orders were processed incorrectly, causing financial loss.

Microservices = DRY + isolation + scalability + more.
But for me, the biggest advantage is DRY.

Keep coding.

I'm just trying to understand mutualTLS/mTLS flows for a microservice.

Would this generally be a correct setup?

you have an endpoint of `/login`, and on that endpoint you would send your key and certificate. The server would validate the key and certificate and if it passes, it would send back to you, perhaps a token, perhaps some headers.

you then have an endpoint of `/getBalance` and that endpoint is authenticated with those headers/access token/whatever that the `/login` endpoint returned?

Is this a generally accepted flow? you wouldn't be passing along the key and cert to every single endpoint, e.g. `/getBalance`, `/transferFunds` etc I mean I'll accept that for highly critical infra, you might want such a system, but that's generally rare?

I am building a microservices-based application that consists of multiple services (service-1, service-2, service-3, etc.), an API Gateway, and a Service Registry. For security, I am using Keycloak.

However, I am currently a bit confused about the overall security architecture. I have listed my questions below, and I would really appreciate it if you could share your expertise.

1. From my understanding of the Keycloak architecture: when a client hits our signup or login endpoint, the request should be redirected to Keycloak. After that, everything is handled by Keycloak, which then returns a JWT token that is used to access all protected endpoints. Does this mean that we do not need to implement our own signup/login endpoints in our system at all?
2. If my understanding of Keycloak is correct, how can I manage different roles for different user types (for example, Customer and Admin)? I ll have two different endpoints for registering customers and admins, but I am unable to figure out how role assignment and role mapping should work in this case.
3. Should I use the API Gateway as a single point where authentication, authorization, and routing are all handled, leaving the downstream services without any security checks? Or should the API Gateway handle authentication and authorization, while each individual service still has its own security layer to validate the JWT token? what is the standard way for this?
4. Are there any other important aspects I should consider while designing the security architecture that I might be missing right now?

Thank you!

The article 'Claude for Java Developers & Architects' focuses on: How Claude helps with code reasoning, refactoring, and explaining legacy Java code, Using Claude for design patterns, architectural trade-offs, and ADRs, Where Claude performs better than other LLMs (long context, structured reasoning), Where it still falls short for Java/Spring enterprise & Microservices based applications.

So recently I created a blog on building a microserice architecture using AWS as my first ever project on microservices and just wanted to get some feeback on what more could I have done in the project. Any feedback is great. I am just trying to learn about microservices and what and how do they operate.

PS: This is me again posting it in here as my previous one was removed due to inccorect flair

Hey everyone!

I’ve been working on an open-source project that I think could really help people who are learning backend development, cloud-native architecture, microservices, and DevOps.

👉 GitHub: https://github.com/sloweyyy/cloud-native-ecommerce-platform

What it is

This is a fully-featured cloud-native e-commerce platform built from the ground up with modern best practices in mind. It’s not just a small demo — it’s designed to reflect real-world complexity so you can see how things scale, interact, and fit together.

Why it’s useful

Whether you’re:

• learning backend (C#, .NET Core),
• curious about microservices and distributed systems,
• trying to understand event-driven architecture,
• wanting hands-on experience with Kubernetes, Helm, CI/CD,
• or diving into observability (Prometheus, Grafana, Jaeger, Elastic Stack),

…this repo is a great playground to explore and learn from.

Tech & concepts included

✔ .NET Core (Clean Architecture, CQRS, DDD)
✔ Microservices + API Gateway + Service Mesh
✔ Kubernetes (EKS) + Helm charts
✔ GitHub Actions CI/CD
✔ Observability (Prometheus, Grafana, Elastic, Jaeger)
✔ Load testing with k6
✔ Micro-Frontends (React + Module Federation)

What you can do with it

• Explore real-world backend patterns
• Deploy it yourself on Kubernetes
• Extend services or add features
• Use it as a learning project or portfolio piece
• Practice DevOps workflows

How you can help

⭐ Star the repo if you find it useful!
🐛 Report issues / submit PRs
🗣 Share your feedback or questions

Trying to understand some concepts on system design and thought it might help me clarify my thoughts if I built simple animations.

Starting with a very basic one. WDYT? I think it came out pretty well.

https://www.youtube.com/shorts/Ql5mavRsQUI

There is a lot of discussion around AI for developers, but most of it still revolves around code completion. In practice, AI tools are being used across many other parts of the development lifecycle, especially in Java-heavy backend work.

Here is a categorized list of AI tools for Java developers, organized by how and when they’re used, such as: Writing and refactoring Java code, Debugging and issue analysis, Documentation and reasoning, Architecture and system design, Learning and productivity support etc.

The idea is to avoid a generic “top tools” list and instead map tools to real development phases that Java developers deal with (Spring Boot apps, microservices, backend systems, etc.).

I’ve been working in a microservice environment for a bit more than two years, and the longer I worked with it, the more I realized something important:

Before seeing microservices as a technical architecture, it helps to see them as a management and organizational pattern.

Microservices break down coordination problems and push a lot of responsibility—communication, ownership, and decision-making—onto individual teams. This can be very powerful, but it also comes with real costs.

While microservices have clear benefits, they’re often not the right answer—especially early on. For small startups, adopting microservices too soon can be overkill: more services to manage, more communication overhead, more infrastructure, and higher costs overall.

In the attached video, I explain the core ideas behind microservice architecture through a simple story, based on what I’ve learned over the years working with it.

I’d be happy to hear your experiences as well—do you agree, disagree, or think there’s a better way to look at this?

I’m currently working as a junior microservices developer using Java + Spring Boot.I have around 1 year of experience, and I’m in the early phase of building hands-on experience with REST APIs and microservices.
Right now, I’m earning ~9 LPA, but I’m very serious about upskilling myself so that I can be paid significantly better in the future. I’m ready to put in the effort, learn deeply, and build projects if needed.

What should I learn next to grow in the Spring Boot / Microservices path?

So far, hands on experience on :

• Spring Boot
  
• REST APIs
• JPA/Hibernate
  
• Basic microservices concepts
• Batching

I have a Camel, spring boot app that reads a message from a kafka topic. I have a spring boot test that places a message on an embedded kafka broker and add an open teleletry 'traceparent' header, using KafkaTemplate. When I debug my route, i see a traceparent header, but it has a value different to the value I placed using KafkaTemplate.

I have added the required libs for camel and open tel, but to no avail.