AWS re:Invent 2025-Using event-driven architectures to modernize legacy applications at scale-API207

Modernizing Legacy Applications with Event-Driven Architecture

Understanding Event-Driven Architecture

• Event-driven architecture (EDA) is an architectural style where components communicate by emitting and responding to events
• Key EDA concepts:
  • Events: Something that has happened in the system, represented in the past tense
  • Event producers: Components that emit events
  • Event consumers: Components that respond to events
• Benefits of EDA:
  • Loose coupling and agility: Components can be built and scaled independently
  • Scalability: Components can scale based on business needs
  • Resiliency: Failures in one component don't cascade to the entire system
  • Handling complex integrations: EDA abstracts integration complexities

Decomposing Monolithic Applications

• Challenges with monolithic applications:
  • Complexity, lack of scalability, and impact on business continuity
• Applying domain-driven design and event storming:
  • Understand the business domain and identify relevant domain events
  • Define bounded contexts and microservice boundaries based on events
• Advantages of microservices:
  • Independent development, deployment, and scaling of services
  • Reusability of services and ability to leverage cloud-native patterns

Event-Driven Architecture Patterns

1. Queue-based Communication:

   • Producers send messages to a queue, and consumers pull messages from the queue
   • Useful for scenarios requiring transactionality and single-message consumption

2. Stream-based Communication:

   • Producers emit events to a stream, and consumers can replay events as needed
   • Suitable for scenarios requiring event replay and processing at a certain frequency

3. Event Bus Architecture:

   • An event router (service bus) receives events from producers and routes them to consumers based on defined rules
   • Enables push-based communication, where the event router is responsible for delivering events to consumers

4. Publish-Subscribe Architecture:

   • Producers publish events to topics, and consumers subscribe to the relevant topics
   • Allows for one-to-many communication, where multiple consumers can receive the same event

Implementing EDA for the Philips Use Case

• Philips had a legacy machine-to-machine (M2M) backend for 20,000 critical medical devices
• Challenges:
  • End-of-life for the M2M system, requiring a replacement
  • Complexity of the legacy API-driven, monolithic backend
  • Inability to touch the devices in the field due to cost and compliance constraints
• Solution approach:
  1. Understand the domain and identify key events using domain-driven design and event storming
  2. Decompose the monolithic backend into microservices based on the identified events and bounded contexts
  3. Implement event-driven communication patterns:
     • Queue-based communication for transactional workflows (e.g., device registration)
     • Stream-based communication for long-running processes (e.g., file transfer)
     • Event bus architecture for cross-domain communication and choreography
     • Publish-subscribe for notifications and alerts
  4. Leverage AWS serverless services (e.g., Amazon EventBridge, AWS Step Functions) to build the EDA solution

Key Outcomes and Benefits

• Successful migration of 20,000 critical medical devices to a modern, event-driven architecture
• Avoided $20 million in field service costs by eliminating the need to physically touch the devices
• Achieved zero disruption and zero downtime during the migration
• Implemented a scalable, reliable, and compliant solution using AWS serverless services
• Laid the foundation for a future-proof platform that can adapt to evolving business needs

Lessons Learned and Takeaways

• Start with understanding the business domain and identifying relevant events, not the technology
• Apply architectural patterns like domain-driven design and event storming to define the right microservice boundaries
• Leverage event-driven communication patterns (queue-based, stream-based, event bus, publish-subscribe) to address different integration requirements
• Utilize AWS serverless services to rapidly build and deploy the event-driven architecture
• Focus on platform thinking, not just point solutions, to create a scalable and adaptable solution