How Open Collaboration Made Atomikos Even More Flexible In modern Java architectures, flexibility isn’t a luxury — it’s a requirement.

| | Success stories, Tech tips | untagged

In modern Java architectures, flexibility isn’t a luxury — it’s a requirement.

As teams move toward microservices, serverless deployments, and externalized infrastructure components, control over resources like database connections becomes just as important as transaction reliability itself.

This is where open collaboration across the ecosystem truly shines.

A Real-World Limitation Meets a Real-World Need

While working on integration scenarios, the team behind Open J Proxy — a relational database proxy designed for Java applications — ran into a practical limitation in Atomikos:

Connection pooling could not be disabled.

At first glance, this might not seem like a big deal. But in advanced architectures, it creates friction.

Open J Proxy, for example, manages connections centrally:
  • It uses your database drivers for proxy
  • Applications connect via virtual connections
  • The proxy controls the actual number of database connections
This approach enables:
  • Better resource efficiency (“less is more” with DB connections)
  • Elastic scaling for microservices and serverless workloads
  • Centralized control over connection limits
However, combining external pooling (proxy) with internal pooling (Atomikos) led to conflicts — a classic case of two layers trying to solve the same problem.

The Proposal: Make Pooling Optional

Instead of working around the limitation, the Open J Proxy team proposed a simple but powerful idea:

Allow connection pooling in Atomikos to be turned off — while keeping transaction management fully intact.

This would enable:
  • Seamless integration with external pooling solutions
  • Cleaner architecture boundaries
  • More control in modern cloud-native setups

From Suggestion to Shipping Feature

The Atomikos team reviewed the proposal — and acted on it.

The enhancement was implemented and released in Atomikos 6.0.1.

The result: connection pooling can now be disabled when needed

More details here

Why This Matters

This seemingly small change unlocks major benefits across the ecosystem:

1. Greater Flexibility

Developers can now decide where pooling belongs — inside Atomikos or elsewhere.

2. Better Integration

Works cleanly with:
  • Open J Proxy
  • Oracle UCP
  • Other external connection management systems

3. Cloud-Native Alignment

Modern architectures often favor:
  • Decoupled infrastructure layers
  • Centralized resource control
  • Stateless application instances
Atomikos now fits even more naturally into these environments.

4. No Compromise on Reliability

You still get what Atomikos is known for:
  • Exactly-once guarantees
  • XA-compliant distributed transactions
  • Reliable updates across databases and messaging systems
No retries. No duplicates. Just results.

A Broader Lesson for the Java Ecosystem

This is more than a feature update — it’s a case study in how open collaboration drives progress.
  • A real-world use case surfaced a limitation
  • A focused proposal addressed it
  • The maintainers responded thoughtfully
  • The entire ecosystem benefits
Small, targeted improvements like this often have outsized impact.

Final Thoughts

Atomikos continues to position itself as a lightweight, cloud-native transaction manager for Java microservices — one that adapts to modern architectures instead of constraining them.

And this update reinforces an important idea:

The best infrastructure tools evolve not just through design — but through collaboration.
RSS

Comments

Add a comment

Corporate Information

Atomikos Corporate Headquarters
Hoveniersstraat, 39/1, 2800
Mechelen, Belgium

Contact Us

Copyright 2026 Atomikos BVBA | Our Privacy Policy
By using this site you agree to our cookies. More info. That's Fine