Blog - Atomikos https://www.atomikos.com/Blog The Atomikos Blog /pub/Main/SitePreferences/atomikos_logo.webp Blog - Atomikos https://www.atomikos.com/Blog en-us Copyright 2026 Atomikos BVBA How Open Collaboration Made Atomikos Even More Flexible https://www.atomikos.com/Blog/HowOpenCollaborationMadeAtomikosEvenMoreFlexible https://www.atomikos.com/Blog/HowOpenCollaborationMadeAtomikosEvenMoreFlexible?_t=1794557889 Guy Pardon 2026-11-13T09:18:09Z Success stories Tech tips

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.

]]>
7 Microservice Data Consistency Failures That Hide Behind the Happy Path https://www.atomikos.com/Blog/7MicroserviceDataConsistencyFailuresThatHideBehindTheHappyPath https://www.atomikos.com/Blog/7MicroserviceDataConsistencyFailuresThatHideBehindTheHappyPath?_t=1794305673 Guy Pardon 2026-11-10T11:14:33Z Vision

Your microservices work perfectly when everything goes according to plan. But what happens when a database commits, a message disappears, or a network timeout leaves you guessing? Here are seven data consistency failures that can quietly compromise your system.

Microservices make it easier to build, deploy, and scale applications independently. But they also introduce a challenge that is easy to underestimate: keeping data consistent across services, databases, and message brokers.

In a monolithic application, several related updates can often be handled within a single database transaction. Either all changes commit, or none do.

In a microservices architecture, those same operations may involve multiple independent systems:
  • A database storing an order
  • A message broker distributing an event
  • A payment service processing a transaction
  • Another database maintaining inventory
Each system may successfully complete its own operation. But that doesn't guarantee that the overall business transaction succeeds.

And that's where things get interesting.

Most microservice data consistency problems don't appear during normal operation. They emerge when something unexpected happens: a process crashes, a network connection fails, a message is redelivered, or a service restarts at precisely the wrong moment.

The result? Lost messages, duplicate updates, inconsistent databases, and business operations that appear successful in one system but fail in another.

Let's examine seven common failure scenarios, why they happen, and what you can do to prevent them.

1. Lost Messages: The Database Commits, but the Event Never Arrives

Imagine an order-processing service that performs two operations:
  • Saves a new order in its database.
  • Publishes an OrderCreated event to a message broker.
The developer decides to commit the database transaction first and publish the message afterward.

That seems reasonable. After all, why publish an event before the order actually exists?

But consider this sequence:
  • The application saves order #1234.
  • The database transaction commits successfully.
  • The application crashes before publishing OrderCreated.
  • The service restarts.
The order exists in the database, but no event was published.

Downstream services may never learn that the order was created. Inventory remains unchanged. Shipping is never initiated.

From the database's perspective, everything worked. From the business perspective, the workflow is incomplete.

Why retries don't necessarily solve this

A retry can help only if the application knows that an event still needs to be published.

After a crash, the original process may have lost that information. Unless the application durably records the pending publication, there may be nothing to retry.

How to prevent lost messages

Several approaches can address this problem:
  • Transactional outbox: Store the business update and an outgoing event record in the same local database transaction. A separate process publishes the event afterward.
  • Transaction coordination: Use a distributed transaction to coordinate database and message-broker operations when both resources support a compatible transactional protocol.
  • Reconciliation: Detect missing downstream updates and repair them, although this generally provides eventual rather than immediate consistency.
For Java applications using XA-capable JDBC databases and JMS brokers, a transaction manager such as Atomikos can coordinate the operations so they share a common commit outcome.

The important distinction is that two successful individual operations are not automatically one reliable business transaction.

2. Ghost Messages: The Event Exists, but the Database Update Doesn't

What if you reverse the order?

Instead of committing the database first, the application publishes the message before committing the database transaction.

That might seem to solve the lost-message problem.

Unfortunately, it creates the opposite failure.

Consider the same order-processing service:
  • The application receives an order request.
  • It publishes an OrderCreated event.
  • Another service receives the event and starts processing it.
  • The original database transaction fails or rolls back.
Now the event exists, but the order doesn't.

This is a ghost message: an event announcing a business change that never actually committed.

Why ghost messages are dangerous

A ghost message can trigger real business consequences.

A shipping service might prepare an order that doesn't exist. A billing service might initiate payment processing. An inventory service might reserve products unnecessarily.

The receiving services have no reason to assume that the published event represents an uncommitted operation.

Why changing commit order doesn't help

Committing the database first risks lost messages.

Publishing the message first risks ghost messages.

Neither ordering guarantees atomicity because the database and broker are independent transactional resources.

How to prevent ghost messages

The transactional outbox pattern avoids publishing an event before the corresponding business update commits.

Alternatively, when supported, XA transaction coordination can ensure that the database update and message publication participate in one coordinated transaction.

The lesson: Commit order alone cannot guarantee consistency across independent systems.

3. Duplicate Messages: One Business Event Gets Published Twice

Distributed systems frequently encounter situations where an operation succeeds, but the caller never receives confirmation.

Imagine that an order service publishes an event:
  • The application sends OrderCreated.
  • The broker accepts and persists the message.
  • The application crashes before it marks the message as sent.
  • The application assumes publication failed.
  • It retries the publication.
Now two copies of the same business event may exist.

The application intended to publish once. The broker received it twice.

Why duplicates matter

Duplicate messages aren't always harmless.

Suppose a downstream consumer processes each event by creating a shipment, updating an account balance, or issuing a customer notification.

Without protection, duplicate events can produce duplicate business effects.

Why retries can make the problem worse

Retries improve availability when operations fail temporarily.

But when the outcome is unknown, retrying can repeat an operation that already succeeded.

This is one of the fundamental challenges of distributed systems: an acknowledgement failure is not proof that the original operation failed.

How to prevent duplicate messages

Possible solutions include:
  • Idempotent consumers: Ensure processing the same business event multiple times produces only one intended business effect.
  • Deduplication: Track processed event identifiers and reject duplicates. Often used to achieve “idempotency” like above.
  • In general, these approaches require significant complexity in ALL downstream consumers of a message. The complexity becomes viral.
  • Transactional messaging: Coordinate publication with the relevant transactional resources where supported. This avoids an explosion of downstream complexity so it pays off many times.
An outbox alone does not guarantee that a message will never be published twice. A publisher may crash after successfully sending an event but before marking it as delivered.

This is why reliable publication and reliable consumption must be considered together.

4. Lost Consumer Updates: The Message Disappears Without Changing the Database

The previous examples focused on message producers.

But consumers face similar problems.

Imagine an inventory service receiving an OrderCreated event.

Its job is to update the inventory database and acknowledge the message to the broker.

Suppose it acknowledges the message first.
  • The inventory service receives OrderCreated.
  • It acknowledges the message.
  • The broker considers the message handled.
  • The inventory service attempts to update the database.
  • The database update fails.
The message has been acknowledged, but inventory was never updated.

Depending on the broker's acknowledgement semantics, the message may no longer be available for redelivery.

Why this is difficult to detect

The broker may report successful message consumption.

The database may show no corresponding update.

Neither system necessarily identifies the mismatch as a distributed transaction failure.

Monitoring message queues alone won't reveal the missing business effect.

How to prevent lost consumer updates

Where supported, coordinate the database transaction and broker acknowledgement in one distributed transaction.

For example, a Java application using a compatible JMS broker and XA-capable JDBC database can use Atomikos to coordinate both resources.

If transactional coordination isn't available, applications need a carefully designed consumption strategy, durable state tracking, and reconciliation.

The goal is to ensure that a message is not permanently considered processed before its required database effects are safely committed.

5. Duplicate Message Processing: One Message Creates Two Business Effects

What if the consumer updates the database first and acknowledges the message afterward?

This avoids acknowledging messages before the business update commits.

But it introduces another failure window.

Consider the following:
  • The inventory service receives an order event.
  • It reduces the available inventory by one unit.
  • The database transaction commits.
  • The application crashes before acknowledging the message.
  • The broker redelivers the message.
  • The service reduces inventory again.
One order has now reduced inventory twice.

The broker behaved correctly according to its redelivery semantics. The database also committed both updates successfully.

Yet the business outcome is wrong.

Isn't at-least-once delivery enough?

At-least-once delivery is designed to avoid losing messages, but it permits redelivery.

That means the application must be prepared to encounter the same message more than once.

If the consumer isn't idempotent, redelivery can create duplicate effects.

How to prevent duplicate processing

One common approach is to store a unique message identifier alongside the business update, in the same local database transaction.

Before processing, the consumer checks whether the identifier has already been handled.

If it has, the duplicate can be ignored.

For compatible transactional resources, XA coordination provides another approach by coupling the database update with the broker's transactional message consumption.

However, no transaction manager can automatically make arbitrary non-transactional side effects, such as an external HTTP call, execute exactly once.

Exactly-once business processing requires guarantees across the entire relevant operation, not just the message broker.

6. Partial and Duplicate Remote Commits: A Timeout Doesn't Tell You What Happened

Not every microservice architecture uses asynchronous messaging.

Many applications communicate through synchronous REST or SOAP calls.

These interactions introduce a different consistency problem: the caller may not know whether a remote operation committed.

Imagine a payment service receiving a request to charge a customer €100.
  • The order service sends the payment request.
  • The payment service processes the charge.
  • The payment transaction commits.
  • The network connection fails before the response reaches the order service.
  • The order service receives a timeout.
Did the payment fail?

No. The payment may have succeeded.

But the caller doesn't know.

The danger of retrying

If the order service retries the request, the payment service might process a second charge.

A single timeout can therefore lead to a duplicate remote commit.

The opposite problem is also possible: the remote operation may have failed before committing, leaving the caller uncertain about what happened.

How to handle unknown outcomes

The right solution depends on the remote system's capabilities.

Common techniques include:
  • Idempotency keys: Associate repeated requests with one logical business operation.
  • Status queries: Check the remote operation's outcome before retrying.
  • Transaction-aware integration: Use coordinated transactional resources where the underlying protocols and systems support them.
  • Reconciliation: Compare records across systems and resolve discrepancies.
Circuit breakers can prevent repeated calls to an unhealthy service, but they don't automatically resolve an uncertain transaction outcome.

A circuit breaker can tell you to stop calling a service. It cannot tell you whether the previous business operation committed.

This distinction is especially important for payments, transfers, reservations, and other operations where duplicate execution has real consequences.

7. Inconsistent Recovery: Your Databases Are Restored, but Your Business Data Isn't

Microservice applications often use multiple databases.

An order service might use PostgreSQL. An inventory service might use another relational database. A reporting service might use a document database.

This approach, often called polyglot persistence, allows teams to choose storage technologies that suit their requirements.

But it introduces a subtle disaster-recovery problem.

The recovery scenario

Imagine a business operation that updates two databases.

At 10:00:00, database A records a new order.

At 10:00:01, database B records the corresponding inventory change.

Now imagine the databases are backed up independently.
  • Database A is restored to a point after the order was committed.
  • Database B is restored to a point before the inventory change.
Both databases restore successfully.

But the combined system is inconsistent.

The order exists, while the corresponding inventory update does not.

Why successful backups aren't enough

A valid backup of each individual database doesn't guarantee a transactionally consistent snapshot of the entire application.

The problem is not necessarily backup corruption.

It's the absence of a common recovery boundary across systems.

How to improve recovery consistency

Possible approaches include coordinated recovery procedures, transaction-log retention, consistent snapshot mechanisms, and application-level reconciliation.

Where compatible XA resources participate in distributed transactions, transaction recovery mechanisms can also help resolve transactions that were incomplete during a failure.

Atomikos provides transaction coordination for Java applications, while capabilities such as LogCloud support transaction recovery in distributed environments.

However, transaction recovery and disaster recovery are not identical. Recovering an in-doubt transaction doesn't automatically make independently captured database backups mutually consistent.

A complete recovery strategy must account for both transaction outcomes and the consistency of restored data.

Summary: Seven Microservice Data Consistency Failures

These seven failures share a common theme: independent systems can each behave correctly while the overall business process becomes inconsistent.
Failure Example outcome Underlying problem
1. Lost producer message Order commits, event never appears Database and broker commit independently
2. Ghost message Event is published, order rolls back Publication precedes business commit
3. Duplicate producer message One event is published twice Unknown publication outcome followed by retry
4. Lost consumer update Message acknowledged, database unchanged Acknowledgement and database commit are separate
5. Duplicate processing One event causes two inventory updates Redelivery repeats a committed business effect
6. Partial or duplicate remote commit Payment succeeds despite timeout, then runs again Caller cannot determine remote commit outcome
7. Inconsistent recovery Restored databases disagree about an order Recovery points lack a shared consistency boundary

Why Microservice Data Consistency Is Harder Than It Looks

The central problem isn't that databases, message brokers, or HTTP APIs are inherently unreliable.

It's that they provide different transactional guarantees.

A database transaction can protect changes inside one database.

A message broker can provide durable delivery and acknowledgement mechanisms.

An HTTP API can report whether a request received a successful response.

But none of these guarantees automatically makes a multi-system business operation atomic.

This is why choosing the right consistency mechanism matters.

Common approaches to microservice consistency

Idempotency and deduplication help prevent repeated requests or message deliveries from producing duplicate business effects. They are especially useful when at-least-once delivery is unavoidable.

The transactional outbox pattern couples a business database update with durable event creation. It can eliminate the gap between committing business data and recording an outgoing event, although publication and downstream processing still require appropriate duplicate handling.

Saga patterns coordinate a sequence of local transactions through events or commands, often using compensating actions when later steps fail. They can be appropriate for long-running workflows, but compensation is not equivalent to atomic rollback and will always introduce additional application complexity.

XA transaction coordination enables compatible transactional resources to participate in a distributed transaction, typically using two-phase commit. This can be particularly useful when a Java application must coordinate JDBC database operations and JMS messaging without implementing custom compensation or deduplication for those coordinated operations.

No single approach fits every architecture.

For example, XA cannot directly coordinate arbitrary REST APIs or every Kafka deployment. And even when XA is available, applications must account for resource compatibility, availability, recovery, and operational trade-offs.

The key is to select a consistency model based on the actual failure scenarios your application must handle.

Where Atomikos Fits

For Java teams working with transactional databases and messaging systems, Atomikos provides a lightweight alternative to managing distributed transactions through heavyweight application servers.

Atomikos is an XA-compliant transaction manager that integrates with Java technologies such as JDBC, JMS, Spring Boot, and Hibernate.

It helps coordinate supported resources so related database and messaging operations can commit or roll back as one transaction.

This can eliminate entire classes of lost-message, ghost-message, and duplicate-processing failure windows associated with independently committed operations.

Unlike approaches that require developers to implement compensation workflows across multiple services, transaction coordination can keep consistency logic closer to the infrastructure layer when the participating resources support it.

Atomikos also supports cloud-native Java deployments without requiring a traditional application server, with LogCloud providing capabilities for decentralized transaction recovery.

For teams building financial systems, order-processing platforms, or other applications where data consistency is critical, this can significantly reduce the amount of custom reliability logic they need to maintain.

Diagnostic Checklist: Is Your Microservice Architecture at Risk?

Before assuming your system is reliable, ask these questions:
  • Does any service update a database and publish a message as separate operations?
  • Can a message be acknowledged before the corresponding database transaction commits?
  • Can a consumer process the same business event more than once?
  • Does your application retry operations after a timeout without checking whether the original request succeeded?
  • Do you rely on commit order to guarantee consistency between independent resources?
  • Are your database backups created and restored without checking cross-system consistency?
  • Have you tested what happens when a service crashes between two related operations?
  • Do you know which parts of your application provide at-most-once, at-least-once, or effectively exactly-once business processing?
If you answered yes to any of the first seven questions, or cannot answer the last one confidently, your architecture deserves a closer consistency review.

The most important test isn't whether your application works when every component is healthy.

It's whether the system remains correct when something fails halfway through a business operation.

Final Thoughts: Don't Let the Happy Path Define Reliability

Microservices are designed to make applications more modular, scalable, and independently deployable.

But distributing an application also distributes its failure modes.

Lost messages, ghost events, duplicate processing, uncertain remote commits, and inconsistent recovery aren't necessarily the result of poor programming.

They're predictable consequences of coordinating operations across independent systems without sufficient transactional guarantees.

The good news is that these failures can be addressed.

Depending on your architecture, the solution may involve transactional messaging, idempotency, an outbox, recovery coordination, or XA transactions.

What matters is understanding the failure windows before they affect production.

Because reliable microservices aren't just about making individual operations succeed. They're about keeping the entire business transaction consistent—even when things go wrong.

Build More Reliable Java Microservices with Atomikos

Are you coordinating database updates and messaging in a Java microservices architecture?

Discover how Atomikos helps you simplify distributed transaction management, prevent inconsistent updates, and coordinate supported JDBC and JMS resources without a heavyweight application server.

Explore Atomikos transaction management →

Or download our Microservice Data Consistency Pitfalls cheat sheet for a quick reference to the seven failure scenarios covered in this article.

Send me the PDF!

]]>
How to use Atomikos without Spring: Distributed Transactions in Standalone Java Applications https://www.atomikos.com/Blog/UsingAtomikosWithoutSpring https://www.atomikos.com/Blog/UsingAtomikosWithoutSpring?_t=1794222485 Guy Pardon 2026-11-09T12:08:05Z Tech tips

Did you know you can manage distributed transactions in Java without Spring or a heavyweight application server? Discover how Atomikos simplifies transaction management in standalone Java applications, batch processes, and Tomcat-based web applications using JTA/XA.

Spring Framework and Spring Boot are popular choices for building Java applications. But what if your application doesn't use Spring?

Perhaps you are developing a standalone Java service, running batch jobs, maintaining an existing Java application, or simply prefer to manage your application's components directly.

The good news: you don't need Spring or a heavyweight application server to use Atomikos.

Atomikos is a lightweight, embeddable transaction manager that supports distributed transactions across XA-capable resources such as databases and JMS message brokers.

Let's look at the options for using Atomikos without Spring.

Why use Atomikos without Spring?

Distributed transactions become important when an application needs to coordinate updates across multiple transactional resources.

Imagine a Java batch application that needs to update a database and send a JMS message as part of the same business operation.

Without proper transaction coordination, one operation might succeed while the other fails, leaving your systems inconsistent.

With JTA/XA and compatible resources, Atomikos can coordinate these operations within a single distributed transaction.

And because Atomikos is embedded in your application, you don't need Spring or a traditional Java EE application server to provide transaction management.

Using Atomikos in batch applications

For standalone Java applications and batch processing, Atomikos provides components for transaction management and connecting to transactional resources.

The original article identifies the following components:
Component Purpose
TransactionTemplate Define transaction boundaries in application code
AtomikosConnectionFactoryBean Connect to a JMS/XA message broker
AtomikosDataSourceBean Connect to a JDBC/XA database
AtomikosContextFactory Access Atomikos resources through JNDI, for example with JPA or Hibernate
MessageDrivenContainer Process JMS messages
JmsSenderTemplate implementations Send JMS messages

Example use case: Database updates and JMS messaging

Consider a batch process that reads records, updates a database, and publishes messages to a JMS queue.

If the database update succeeds but the message operation fails, the application may end up in an inconsistent state.

When both resources support XA, Atomikos can coordinate them so that the transaction commits successfully across both resources or rolls back when the transaction cannot complete.

This can reduce the need to implement custom compensation or duplicate-handling logic for the coordinated operations.

Using Atomikos in web applications without Spring

Atomikos can also be integrated with Apache Tomcat to provide JTA transaction management and access to transactional JDBC and JMS resources.

This can be useful for teams that want transaction coordination without deploying a full Java EE application server.

For details, see the Atomikos Tomcat Integration documentation.

Check the supported Tomcat versions and integration options before adopting an older configuration example.

Do you need Spring for distributed transactions?

No.

Spring can make application configuration and transaction management more convenient, but it isn't a prerequisite for using JTA/XA with Atomikos.

Whether you are building standalone Java applications, batch processes, or Tomcat-based web applications, Atomikos offers ways to coordinate distributed transactions without relying on Spring.

The important requirement is that the resources participating in the distributed transaction support the necessary XA capabilities.

Ready to evaluate Atomikos?

If you are planning to run distributed transactions in a production environment, you may also need to consider recovery, operational reliability, and commercial support.

Explore Atomikos ExtremeTransactions and its free trial to evaluate whether it meets your production requirements.

Free Trial

]]>
ExtremeTransactions 6.0.120 https://www.atomikos.com/Blog/ExtremeTransactions6dot0dot120 https://www.atomikos.com/Blog/ExtremeTransactions6dot0dot120?_t=1791540200 Guy Pardon 2026-10-09T12:03:20Z Release notes

A correctness fix for JMS connection pooling: concurrently closing sessions of a pooled connection can no longer deadlock the pool, so a connection that fails asynchronously (for example an IBM MQ connection drop) is reliably detected and replaced.

Bug230921
JMS connection pool could deadlock when sessions are closed concurrently

Severity:2
Affected version(s):6.0.x

Description

A pooled JMS connection no longer deadlocks when two threads concurrently close different sessions of the same connection, so the pool can reliably reclaim and replace that connection instead of leaving a pool thread stuck.

Technical details

Each JMS session proxy holds its own monitor while it closes, and the close path drove the connection's termination - closing the remaining sessions and announcing the connection as available to the pool - from inside that monitor. Two threads each closing a different session could therefore hold their own session monitor while reaching for the other's: a lock-ordering deadlock. The same path was also not atomic between deciding the connection was available and announcing it, so under the same race a connection that had already been handed back out could be announced available a second time and borrowed by two threads at once.

Termination is now single-shot per borrow: a guard taken under the connection's own monitor ensures at most one thread runs the session teardown and the availability announcement, while the announcement itself still runs outside the monitor. Concurrent close is therefore both deadlock-free and free of the double hand-out. The behaviour is always on; there is nothing to configure.

Changes impacting client API

None.

SBOM — runtime dependencies are minimalistic

Concerning security and vulnerabilities: the following are the runtime dependencies (the SBOM) of our product. As you can see, the only transitive third-party dependencies are for the Spring Boot integration modules — because that is the only way to integrate with Spring Boot. All other modules / jars have no third-party runtime dependencies whatsoever.

This is compile + runtime scope; provided, test and non-propagating optional dependencies are excluded, so it is what your application actually receives. Look up the module(s) your application depends on.

To reproduce it yourself, run this in a project that depends on the Atomikos artifacts you use (use exactly this — not a bare dependency:tree, which would also list optional/provided libraries you are not given):

mvn dependency:list -DincludeScope=runtime

Modules with no third-party runtime dependencies

ExtremeTransactionsForMaven
ate
atomikos-util
axt
extreme-transactions
extreme-transactions-jakarta
products
spring-boot2
spring-boot3
spring-boot3.4
spring-boot4
subscription
transactions
transactions-allegrograph
transactions-api
transactions-eclipselink
transactions-essentials
transactions-essentials-jakarta
transactions-hazelcast
transactions-hibernate2
transactions-hibernate3
transactions-hibernate4
transactions-jdbc
transactions-jms
transactions-jmx
transactions-jndi-provider
transactions-jsp
transactions-jta
transactions-logcloud
transactions-logutil
transactions-micrometer
transactions-monitoring
transactions-monitoring-logs
transactions-monitoring-stderr
transactions-opentracing
transactions-osgi
transactions-osgi-axt
transactions-remoting
transactions-remoting-recovery
transactions-spring
transactions-spring-boot-logcloud
transactions-tomcat

Per-module third-party runtime dependencies (opt-in, customer-chosen)

The dependencies below appear ONLY if you choose to use the corresponding integration module. They are the platform your application already runs — you added, say, the Spring Boot starter because you use Spring Boot. These are your own, customer-chosen dependencies: Atomikos does not inject anything into your infrastructure; you opt in by depending on the module.

transactions-spring-boot
  org.springframework.boot:spring-boot:2.3.4.RELEASE
  org.springframework:spring-aop:5.2.9.RELEASE
  org.springframework:spring-beans:5.2.9.RELEASE
  org.springframework:spring-context:5.2.9.RELEASE
  org.springframework:spring-core:5.2.9.RELEASE
  org.springframework:spring-expression:5.2.9.RELEASE
  org.springframework:spring-jcl:5.2.9.RELEASE
  org.springframework:spring-tx:5.2.9.RELEASE

transactions-spring-boot-starter
  org.springframework.boot:spring-boot:2.3.4.RELEASE
  org.springframework:spring-aop:5.2.9.RELEASE
  org.springframework:spring-beans:5.2.9.RELEASE
  org.springframework:spring-context:5.2.9.RELEASE
  org.springframework:spring-core:5.2.9.RELEASE
  org.springframework:spring-expression:5.2.9.RELEASE
  org.springframework:spring-jcl:5.2.9.RELEASE
  org.springframework:spring-tx:5.2.9.RELEASE

transactions-spring-boot3
  jakarta.jms:jakarta.jms-api:3.1.0
  jakarta.transaction:jakarta.transaction-api:2.0.1
  org.springframework.boot:spring-boot:3.0.1
  org.springframework:spring-aop:6.0.3
  org.springframework:spring-beans:6.0.3
  org.springframework:spring-context:6.0.3
  org.springframework:spring-core:6.0.3
  org.springframework:spring-expression:6.0.3
  org.springframework:spring-jcl:6.0.3
  org.springframework:spring-tx:6.0.3

transactions-spring-boot3-starter
  jakarta.jms:jakarta.jms-api:3.1.0
  jakarta.transaction:jakarta.transaction-api:2.0.1
  org.springframework.boot:spring-boot:3.0.1
  org.springframework:spring-aop:6.0.3
  org.springframework:spring-beans:6.0.3
  org.springframework:spring-context:6.0.3
  org.springframework:spring-core:6.0.3
  org.springframework:spring-expression:6.0.3
  org.springframework:spring-jcl:6.0.3
  org.springframework:spring-tx:6.0.3

transactions-spring-boot3.4
  io.micrometer:micrometer-commons:1.12.0
  io.micrometer:micrometer-observation:1.12.0
  jakarta.jms:jakarta.jms-api:3.1.0
  jakarta.transaction:jakarta.transaction-api:2.0.1
  org.springframework.boot:spring-boot:3.2.0
  org.springframework:spring-aop:6.1.1
  org.springframework:spring-beans:6.1.1
  org.springframework:spring-context:6.1.1
  org.springframework:spring-core:6.1.1
  org.springframework:spring-expression:6.1.1
  org.springframework:spring-jcl:6.1.1
  org.springframework:spring-tx:6.1.1

transactions-spring-boot3.4-starter
  io.micrometer:micrometer-commons:1.12.0
  io.micrometer:micrometer-observation:1.12.0
  jakarta.jms:jakarta.jms-api:3.1.0
  jakarta.transaction:jakarta.transaction-api:2.0.1
  org.springframework.boot:spring-boot:3.2.0
  org.springframework:spring-aop:6.1.1
  org.springframework:spring-beans:6.1.1
  org.springframework:spring-context:6.1.1
  org.springframework:spring-core:6.1.1
  org.springframework:spring-expression:6.1.1
  org.springframework:spring-jcl:6.1.1
  org.springframework:spring-tx:6.1.1

transactions-spring-boot4
  ch.qos.logback:logback-classic:1.5.21
  ch.qos.logback:logback-core:1.5.21
  com.zaxxer:HikariCP:7.0.2
  commons-logging:commons-logging:1.3.5
  io.micrometer:micrometer-commons:1.16.0
  io.micrometer:micrometer-observation:1.16.0
  jakarta.annotation:jakarta.annotation-api:3.0.0
  jakarta.jms:jakarta.jms-api:3.1.0
  jakarta.transaction:jakarta.transaction-api:2.0.1
  org.apache.logging.log4j:log4j-api:2.25.2
  org.apache.logging.log4j:log4j-to-slf4j:2.25.2
  org.jspecify:jspecify:1.0.0
  org.slf4j:jul-to-slf4j:2.0.17
  org.slf4j:slf4j-api:2.0.17
  org.springframework.boot:spring-boot-autoconfigure:4.0.0
  org.springframework.boot:spring-boot-data-commons:4.0.0
  org.springframework.boot:spring-boot-data-jdbc:4.0.0
  org.springframework.boot:spring-boot-jdbc:4.0.0
  org.springframework.boot:spring-boot-jms:4.0.0
  org.springframework.boot:spring-boot-persistence:4.0.0
  org.springframework.boot:spring-boot-sql:4.0.0
  org.springframework.boot:spring-boot-starter-data-jdbc:4.0.0
  org.springframework.boot:spring-boot-starter-jdbc:4.0.0
  org.springframework.boot:spring-boot-starter-jms:4.0.0
  org.springframework.boot:spring-boot-starter-logging:4.0.0
  org.springframework.boot:spring-boot-starter:4.0.0
  org.springframework.boot:spring-boot-transaction:4.0.0
  org.springframework.boot:spring-boot:4.0.0
  org.springframework.data:spring-data-commons:4.0.0
  org.springframework.data:spring-data-jdbc:4.0.0
  org.springframework.data:spring-data-relational:4.0.0
  org.springframework:spring-aop:7.0.1
  org.springframework:spring-beans:7.0.0
  org.springframework:spring-context:7.0.1
  org.springframework:spring-core:7.0.0
  org.springframework:spring-expression:7.0.1
  org.springframework:spring-jdbc:7.0.1
  org.springframework:spring-jms:7.0.1
  org.springframework:spring-messaging:7.0.1
  org.springframework:spring-tx:7.0.0
  org.yaml:snakeyaml:2.5

transactions-spring-boot4-starter
  ch.qos.logback:logback-classic:1.5.21
  ch.qos.logback:logback-core:1.5.21
  com.zaxxer:HikariCP:7.0.2
  commons-logging:commons-logging:1.3.5
  io.micrometer:micrometer-commons:1.16.0
  io.micrometer:micrometer-observation:1.16.0
  jakarta.annotation:jakarta.annotation-api:3.0.0
  jakarta.jms:jakarta.jms-api:3.1.0
  jakarta.transaction:jakarta.transaction-api:2.0.1
  org.apache.logging.log4j:log4j-api:2.25.2
  org.apache.logging.log4j:log4j-to-slf4j:2.25.2
  org.jspecify:jspecify:1.0.0
  org.slf4j:jul-to-slf4j:2.0.17
  org.slf4j:slf4j-api:2.0.17
  org.springframework.boot:spring-boot-autoconfigure:4.0.0
  org.springframework.boot:spring-boot-data-commons:4.0.0
  org.springframework.boot:spring-boot-data-jdbc:4.0.0
  org.springframework.boot:spring-boot-jdbc:4.0.0
  org.springframework.boot:spring-boot-jms:4.0.0
  org.springframework.boot:spring-boot-persistence:4.0.0
  org.springframework.boot:spring-boot-sql:4.0.0
  org.springframework.boot:spring-boot-starter-data-jdbc:4.0.0
  org.springframework.boot:spring-boot-starter-jdbc:4.0.0
  org.springframework.boot:spring-boot-starter-jms:4.0.0
  org.springframework.boot:spring-boot-starter-logging:4.0.0
  org.springframework.boot:spring-boot-starter:4.0.0
  org.springframework.boot:spring-boot-transaction:4.0.0
  org.springframework.boot:spring-boot:4.0.0
  org.springframework.data:spring-data-commons:4.0.0
  org.springframework.data:spring-data-jdbc:4.0.0
  org.springframework.data:spring-data-relational:4.0.0
  org.springframework:spring-aop:7.0.1
  org.springframework:spring-beans:7.0.0
  org.springframework:spring-context:7.0.1
  org.springframework:spring-core:7.0.0
  org.springframework:spring-expression:7.0.1
  org.springframework:spring-jdbc:7.0.1
  org.springframework:spring-jms:7.0.1
  org.springframework:spring-messaging:7.0.1
  org.springframework:spring-tx:7.0.0
  org.yaml:snakeyaml:2.5

]]>
The Hidden Cost of Modernizing Legacy Financial Systems: Data Consistency https://www.atomikos.com/Blog/TheHiddenCostOfModernizingLegacyFinancialSystemsDataConsistency https://www.atomikos.com/Blog/TheHiddenCostOfModernizingLegacyFinancialSystemsDataConsistency?_t=1791532027 Guy Pardon 2026-10-09T09:47:07Z Categories nItqCq9R.png

Legacy systems carry visible costs, from maintenance and scarce expertise to operational fragility. But modernization can introduce a less visible cost: application-level consistency, compensation and recovery logic. Here is what financial institutions should evaluate before choosing an architecture.

Legacy systems are expensive. But replacing them without preserving their transaction guarantees can be even more expensive.

Financial institutions modernize to reduce maintenance costs, improve delivery speed and support cloud-native services. Yet breaking a monolithic application into distributed services changes how business transactions fail. An operation that once committed inside one database transaction may now cross several databases, message brokers or services.

When one part succeeds and another fails, the organization has not removed complexity. It has moved that complexity into retries, idempotency, compensation, observability and reconciliation.

That is the hidden risk of modernization:

A new architecture can eliminate legacy infrastructure while accidentally weakening the consistency guarantees on which the business still depends.

The solution is not to avoid modernization. It is to identify which guarantees must survive it—and select transaction patterns accordingly.

Send me the eBook

Why legacy systems become increasingly expensive

Many legacy platforms appear stable because they have processed critical workloads for years. Underneath that stability, however, several costs tend to accumulate.

Maintenance consumes investment capacity

Older systems require specialist skills, vendor support, emergency patches and manual workarounds. As expertise becomes harder to find, keeping the existing platform running absorbs more of the IT budget.

That is not only a maintenance problem. Money and engineering time tied up in the existing environment cannot be invested in new customer services, automation or faster product delivery.

Technical debt slows unrelated change

Every workaround adds dependencies that future projects must understand. A change that appears local may touch undocumented integrations, shared data structures or fragile batch processes.

The cost is cumulative: even projects outside the core legacy platform become slower and riskier.

Operational and compliance demands have changed

Financial services now operate under expectations of continuous availability, traceability, security and recoverability. Demonstrating how a critical operation behaved—and how it recovered after failure—can be difficult when an aging platform lacks modern observability and automation.

Legacy constraints limit innovation

Customers expect real-time information and reliable digital services. A platform designed for a different era may struggle to support rapid releases, elastic capacity and new integrations without creating further fragility.

These pressures make modernization necessary. But necessity does not make every modernization architecture safe.

Modernization changes the shape of a transaction

In a monolithic application, one local database transaction might update an account, record a payment and create the information needed for the next processing step.

After decomposition, the same business operation might involve:
  • A payment service updating its database.
  • A message being published to a broker.
  • Another service updating a second database.
  • A downstream system confirming the result.
The business still sees one operation. The architecture now contains several independently failing parts.

Consider the simplest example: update a database and publish a message.
  • If the database commits and the application crashes before publishing, the message is missing.
  • If the message is published first and the database rolls back, consumers receive an event for a state that does not exist.
  • If the publishing outcome is unknown and the application retries, the message may be sent twice.
Changing the order of the two operations changes the failure window. It does not remove it.

For a financial institution, these failures may affect account balances, payment status, settlement, reconciliation or customer communication. The architecture therefore needs an explicit answer to partial completion.

Eventual consistency is an engineering choice, not a free simplification

Eventual consistency can be the correct model for many distributed systems. It allows services to commit independently and converge later, which is useful when availability and autonomy matter more than an immediate global result.

But “eventual” is not a recovery mechanism by itself. Teams must still design how convergence happens.

That commonly requires:
  • retries for interrupted operations;
  • idempotency or deduplication to make repetition safe;
  • compensating actions for work that has already committed;
  • conflict resolution when services disagree;
  • monitoring to detect inconsistencies;
  • reconciliation processes for unresolved cases;
  • operational procedures when automatic recovery stops.
These mechanisms are not necessarily defects. They are the cost of the chosen consistency model, and they must be included in estimates for development, testing and long-term operation.

The key question is not whether eventual consistency is modern. It is whether temporary inconsistency is acceptable for the particular business operation.

Compensation is not the same as rollback

The distinction matters when teams consider the Saga pattern.

A Saga divides a business workflow into local transactions. If a later step fails, compensating actions attempt to correct earlier committed steps.

This is appropriate for long-running workflows and systems that cannot participate in one transaction. But a compensation is a new business action—not a technical rollback.
  • Refunding a payment is not the same as never charging it.
  • Cancelling a transfer is not the same as never initiating it.
  • Releasing a reservation is not the same as never creating it.
The original action may already have been observed, audited or communicated to another party. The compensation can also fail, which creates another workflow requiring retries, idempotency and monitoring.

For some processes, that is unavoidable and correct. For a short-lived operation across compatible transactional resources, it may be unnecessary complexity.

The main approaches solve different problems

Financial institutions do not need one transaction pattern for every workflow. They need explicit decision criteria.

Approach Best suited to Main trade-off
Local ACID transaction Work contained in one transactional resource Cannot make separate resources atomic
JTA/XA and two-phase commit Short-lived operations across XA-capable databases or JMS resources that require one outcome Requires compatible resources and careful recovery configuration
Saga Long-running workflows with meaningful business compensations Introduces intermediate states and application-level recovery logic
Transactional outbox Reliable asynchronous publication when the database and broker cannot share a transaction Requires a relay and usually duplicate-tolerant consumers
Eventual consistency Workflows where temporary divergence is acceptable Requires convergence, observability and reconciliation mechanisms
Idempotency Making retries or redelivery safer Does not, by itself, make several resource updates atomic

These approaches can be combined. An outbox normally works alongside idempotent consumers. A coordinated transaction may still need idempotency at external boundaries. A Saga may contain steps that use local or distributed transactions internally.

The important point is to select each pattern for the guarantee it actually provides.

Strong consistency still has a place in cloud architectures

Moving to microservices or containers does not automatically make ACID transactions obsolete.

If a Java application needs to update two XA-capable databases—or update a database and send a message through an XA-capable JMS broker—a transaction manager can coordinate those resources through JTA/XA.

Two-phase commit gives the participants one agreed outcome. Durable transaction records allow the transaction manager to finish recovery if a crash interrupts the protocol.

This does not mean every service interaction should participate in a distributed transaction. It means teams should not implement compensation and reconciliation merely because they assume transaction coordination is incompatible with a modern deployment model.

The choice depends on:
  • the consistency required by the business operation;
  • whether the participating resources support XA;
  • how long the transaction remains active;
  • the acceptable latency and availability trade-offs;
  • the required recovery behaviour;
  • the operational cost of the alternatives.

Where Atomikos fits

Atomikos is an embeddable transaction manager for Java. It coordinates XA-capable transactional resources such as JDBC databases and JMS brokers through JTA/XA, without requiring a traditional Java application server.

This allows teams modernizing to Spring Boot and other JVM frameworks to retain coordinated commit, rollback and crash recovery where the business operation requires them.

Atomikos does not replace every Saga, outbox or eventually consistent workflow. Those patterns remain appropriate where resources cannot share a transaction, processes are long-running or temporary inconsistency is acceptable.

Its role is more specific: when compatible transactional resources genuinely need one atomic outcome, Atomikos provides the coordination and recovery infrastructure so teams do not have to approximate that outcome with application-level repair logic.

Seven questions to ask before modernizing a critical workflow

Before decomposing a legacy transaction, document its existing guarantees and ask:

  • What constitutes one business operation?
    Several technical steps may still represent one outcome to the customer.
  • Which partial outcomes would be unacceptable?
    Identify what happens if each individual resource commits alone.
  • Is temporary inconsistency acceptable?
    Define how long it may last and who or what may observe it.
  • Can completed work be meaningfully compensated?
    Include the business, accounting, audit and customer consequences.
  • What happens when recovery itself fails?
    Plan for failed retries, failed compensation and manual intervention.
  • Can the participating resources share a coordinated transaction?
    Check actual protocol and driver support rather than relying on architectural assumptions.
  • How will the outcome be proven after a crash?
    Recovery logs, monitoring, tracing and audit evidence should be designed from the beginning.

Modernization becomes safer when these questions are answered before services and data are separated—not after production exposes an inconsistency.

Modernize the architecture without losing the guarantee

The hidden costs of legacy systems are real: rising maintenance, scarce expertise, technical debt, operational fragility and lost opportunities.

But modernization can create hidden costs of its own if transaction guarantees are replaced without understanding the consequences.

Retries, idempotency, Sagas, outbox patterns, reconciliation and distributed transaction coordination all have legitimate roles. The right architecture begins with the business guarantee and works backward to the simplest pattern that can preserve it.

Modernization should change how the system is built—not accidentally change what the business can trust.

Get the complete financial-services guide

This article is the short version. The full guide, Overcoming the Hidden Costs of Legacy Systems in Financial Services: Modernize Confidently Without Risking Data Integrity, turns the argument into a practical decision framework:

  • the financial, operational, security and compliance pressures of legacy systems;
  • common traps in financial-services modernization;
  • a deeper comparison of two-phase commit, Sagas and eventual consistency;
  • embedded transaction coordination and crash recovery, explained;
  • financial-services modernization scenarios;
  • a seven-step framework for starting with a bounded pilot and expanding.

Send me the eBook

Prefer to see it rather than read about it?

]]>