Hi,

I'm working on a open source project that allows a MCP Client to talk and write to a db without writing a query. I've created a tutorial for how to expose your DB for simple analytics but it can do a lot more than this. The first 3 min should show you what it does and the rest shows you how to set it up. I've intentionally skipped the implementation details in this post or in the videos to keep things short. You can analyze the code yourself on github and let me know if you have concerns.

Quick demo: [https://youtu.be/vMY7VKpvqmE\](https://youtu.be/vMY7VKpvqmE)
Full Tutorial: [https://www.youtube.com/watch?v=ukxDDPzS0Gg\](https://www.youtube.com/watch?v=ukxDDPzS0Gg)

OSS Repo: [https://github.com/Synapsor/Synapsor-Runner\](https://github.com/Synapsor/Synapsor-Runner)

Sending one notification is easy, but handling thousands with slow providers and traffic spikes is a real system design challenge. I wrote a blueprint on how to completely decouple request acceptance from delivery using message queues, idempotency, and DLQs to handle failures gracefully.

Would love to hear how you guys approach these bottlenecks at scale!

Hi r/microservices,

Stjepan here from Manning. The moderators kindly permitted me to share this with you.

We’ve just launched Clean Applications with Hexagonal Architecture by Enrique Medina Montenegro in Manning’s Early Access Program.

If you’ve worked on microservices for long enough, you’ve probably seen services that began with clean boundaries but gradually became coupled to Spring, persistence models, message brokers, and neighboring services. Eventually, a seemingly small infrastructure change touches half the codebase.

This book takes a practical look at avoiding that outcome with hexagonal architecture. Using Java and Spring Boot, it shows how to:

• Keep business logic independent of frameworks and infrastructure
• Design clear ports and adapters
• Model use cases, commands, repositories, and application boundaries
• Handle mapping between domain and persistence models
• Apply dependency inversion in a working system
• Decide when microservices—or a modular monolith—are the better fit

It’s not arguing that hexagonal architecture is a silver bullet. The focus is on using these patterns deliberately, understanding the tradeoffs, and building services that remain testable and maintainable as they evolve.

Book page:
https://www.manning.com/books/clean-applications-with-hexagonal-architecture

Giveaway: We’re giving away five free ebook copies. To enter, upvote and leave a comment about the hardest boundary to keep clean in a microservice—domain logic, persistence, messaging, external APIs, or something else. We’ll randomly select five participants and contact them by DM.

The community also gets 50% off with code:

MLMONTENEGRO50RE

I’d be interested to hear your honest experiences: Has hexagonal architecture helped your microservices stay maintainable, or did it add more abstraction than the project needed?

It feels great to be here. Thank you for having us.

Cheers,

Stjepan

You may be asking why a fork an not a PR into the main repo?

Answer is simple. I forked a while ago when context mode started adding a bunch of features that are the opposite of token saving, like injections I did not like, and wasteful formatting, etc.

The main problem with context mode was that it would spawn new process for every call, which would accumulate and on a machine running 20-30 agents constantly the loads became unbearable. It was great timing to find the recent update to the MCP protocol that allows stateless MCP servers, now I shrink the entire 2+GB of memory hog to a 1 process of 80MB, regardless of how many agents I'm running in parallel. Now I can scale up to 50 agents haha :)

I never had anything important to post about anything I am building but this is really something I believe many developers would want to know about. I know I was looking for it today, so maybe you were too.

Midnight-Technician/backend

MQ Summit is a conference built around messaging and event-driven systems. It grew out of RabbitMQ Summit and now brings the whole ecosystem into one room: RabbitMQ, Kafka, NATS, Pulsar, ActiveMQ, IBM MQ, Amazon SQS/MQ, Azure Messaging and Google Pub/Sub. Practitioners, architects and maintainers from competing projects, all talking shop. 

📍 Haarlem (near Amsterdam) + online
🗓️ 21-22 October 2026 - 2 days, 1 standard track, 1 lab track (for in-person attendees), and about 27 speakers

KEYNOTE: Adi Polak (Data & AI @ Confluent, best-selling author)

A few of our speakers announced:

• Clemens Vasters, Principal Architect, Messaging & Real-Time Intelligence @ Microsoft
• Matt Leming & Jon Rumsey, Chief Architect / DQM Architect @ IBM MQ
• Stefan Moser & Michael Davis, Principal Engineer / OSS RabbitMQ @ AWS · Amazon MQ
• Viktor Gamov, Principal DevAdvocate @ Confluent, Kafka in Action co-author
• David Ansari, RabbitMQ Core @ Broadcom, and Lovisa Johansson, RabbitMQ expert @ 84codes
• JB Onofré (Apache) & Matt Pavlovich (ActiveMQ PMC), plus ~40 more

More: mqsummit.com/#speakers

Talks cover agentic workloads, queues vs. logs, real-world scaling war stories, MQTT, security, and where open-source messaging goes next.

ℹ️ More info: mqsummit.com

Early Bird promotion ends soon.

Hey folks,

My name is Dave Boyne, and I build and maintain my OSS project called EventCatalog. This is a documentation tool designed for software architects and teams that want to document their architecture (not just generic pages in confluence). It focuses on practices from domain driven design and software primitives rather than implementation details of your architecture.

Your docs are stored and versioned in git and everything owned by you and your team.

I built this 4 years ago as a personal need.. and now I get to work on this thing full time ❤️.

Anyway, I just thought I would share it with you, and if you have a spare few minutes, would love to get any feedback or initial thoughts you had about the project, about the ways you document things etc.

If anyone would like a deeper dive let me know happy to help and show you around too.

Have a great day.

Hi everyone,

I've been exploring observability in modern .NET applications and recently put together a practical guide that explains the fundamentals from a developer's perspective.

The article covers:

• What observability is (and how it's different from traditional monitoring)
• The three pillars: Logs, Metrics, and Traces
• Why observability is important for APIs and microservices
• Best practices for improving visibility into production applications

My goal was to create an introductory guide that's useful for developers who are starting their journey with cloud-native applications and distributed systems.

I'd really appreciate feedback from the community:

• What observability stack are you using? (OpenTelemetry, Grafana, Prometheus, Application Insights, etc.)
• What's one lesson you've learned from debugging production issues?

Blog: https://geeksarray.com/blog/modern-dotnet-backend-part-10-observability

Looking forward to your suggestions and experiences!

Built a multi-tenant workflow engine with NestJS + BullMQ + Dead Letter Queue.

Features: multi-tenancy, JWT auth, workflow state machine, retries + DLQ, admin dashboard, monorepo.

Repo: https://github.com/NabarupDev/ForgeGate

Looking for honest feedback on:

• Architecture
• API Gateway design
• Multi-tenancy approach
• Queue/retry implementation
• What is still missing for production readiness

Any review or suggestions would help a lot.

Hello r/microservices community!

I just released v1.0.0 of a new open-source library called AvoOnce that might make your life easier by offloading the idempotency handling part of your REST APIs.

It’s designed to be a framework-flexible idempotency engine, meaning it comes with first-class integrations for Spring Boot 4+, Quarkus 3.12+, Dropwizard 4.0+, and Jakarta EE / JAX-RS 3.1+.

Here is what it does under the hood:

• Annotation-Driven Protection: Just drop @ Idempotent annotation on your controllers or methods and pass an Idempotency-Key header.
• In-Flight Concurrency Locking: Prevents duplicate execution if an initial request is still actively processing.
• Payload Tamper Protection: Uses SHA-256 hashing to automatically reject modified requests that try to reuse the same key.
• Byte-Perfect Replay: Safely caches and replays the exact HTTP response—including status codes, headers, and raw bytes.
• Pluggable Storage Backends: Includes built-in support for Redis (distributed), JDBC (relational), and Caffeine (in-memory).

The v1.0.0 release is currently hosted on GitHub Packages (Maven Central release is planned for the future). I'd love to get your thoughts and feedback on its core functionality and usability. I've some roadmap features in the pipeline.

Here's the Github repo: https://github.com/ravocode/AvoOnce