Microservices have emerged as a widely discussed and adopted way to build modern and scalable applications. They are easier to build, manage and maintain than monoliths due to smaller code bases; they isolate complexity, allowing for smaller, more agile teams to create services, and they are flexible—allowing the use of various platforms, programming languages, and tools since these choices affect only an individual service and a small team at a time.

1. Application Modernisation
through
Event-Driven Microservices
Rishi Doerga
Senior Solutions Engineer

2. Agenda
2
2. Challenges with Monoliths
and Interservice Communication
1. Tenets for Faster Application
Development
3. Event driven architecture
using Kafka
4. Key Benefits from Confluent
5. How we do it?
6. Q&A

3. Tenets for Faster
Application Development
3
Eliminate
Dependencies
Reduce
Technical Debt
and TCO
Build and
Integrate
Scalable Apps

4. Agenda
4
2. Challenges with Monoliths
and Interservice Communication
1. Tenets for Faster Application
Development
3. Event driven architecture
using Kafka
4. Key Benefits from Confluent
5. How we do it?
6. Q&A

5. The origin of monolithic apps
User Interface
Business Logic
Data Layer
Server app
● Short term benefit: Quick time to
value
● Ideal for small orgs/developer
teams
● Single code repository to
manage
● Still being used in startups to
this day

6. 6
Challenges with Monoliths …
Monolith
● Slow: Smallest change requires end-end testing
● Unreliable: A simple error can bring down the entire app
● Expensive: Changes to tech stack are expensive. Barrier
to adopting new programming frameworks
Services
Database

7. 7
Microservices
● Faster release cycles: Smaller modules that can
Independently deployed and upgraded
● Improved Scalability and Reliability: Independently
scale services and recover from errors faster
● Developer autonomy: Choose the right programming
language and data store for each service
Services
Databases
Services
Database
… Have Led to the Adoption of Microservices
Monolith
● Slow: Smallest change requires end-end testing
● Unreliable: A simple error can bring down the entire app
● Expensive: Changes to tech stack are expensive. Barrier
to adopting new programming frameworks

8. Netflix: An early adopter of microservices
Reasons to Modernize (2009):
● Optimize for developer speed (new
features, bug fixes)
● Scale to the next order of magnitude
● 24/7 reliability
30+ independent teams 500+ microservices 2B API requests

9. Two Approaches
For Interservice
Communication
9
REST APIs
Synchronous request/response communication
Messaging Queues
Synchronous or asynchronous communication

10. Service 4
Service 3
Challenges with Using REST APIs for Interservice
Communication
1
0
REST APIs
Synchronous request/response
Challenges
● Slow
Tight coupling means business logic
is rewritten to add new services.
● Unreliable
Requires costly linear scaling.
Unexpected errors are difficult to
recover from.
● Expensive
High operational overhead of
managing services, at scale.
Service 2
Service 5
Service 6
Service 1
API
API
API
API
API
API

11. Challenges with Using Message Queues for
Interservice Communication
11
Messaging Queues
Synchronous or asynchronous
communication
Challenges
● Slow
Lack a common structure, leads
to inter-team dependencies.
● Unreliable
Cannot scale dynamically.
Ephemeral persistence.
● Expensive
Cannot easily integrate with
cloud-native apps.
Service 2
Service 5
Service 4
Service 3
Service 6
Service 1
Messaging Queues
(No common structure to share data, lacks
built-in stream processing, ephemeral
message persistence, low fault-tolerance)

12. Agenda
12
2. Challenges with Monoliths
and Interservice Communication
1. Tenets for Faster Application
Development
3. Event driven architecture
using Kafka
4. Key Benefits from Confluent
5. How we do it?
6. Q&A

13. The Foundational Assumption of Every Database:
Data at Rest
Data at rest
Slow, daily
batch processing
Simple, static
real-time queries
Databases

14. Paradigm for Data in Motion: Event Streams
14
Rich customer
experiences
Real-time
events
Real-time
Event Streams
Cyber Sensor
Healthcare Citizen
Data driven
operations

15. 1
5
Paradigm for Data in Motion: Event Streams

16. 1
6
Using a command processor

17. 1
7
Fully
Decoupled
Paradigm for Data in Motion: Event Streams

18. Confluent enables the new class of
event-driven microservices
1
8
Why Build with Confluent
Asynchronous service
communication and
development
• Decoupled communication
• Pub/Sub messaging
• Elastic scalability
• Persistent storage
• Process data in flight and
real-time
Service 2
Service 5
Service 6
Service 1
Service 4
Service 3

19. Agenda
19
2. Challenges with Monoliths
and Interservice Communication
1. Tenets for Faster Application
Development
3. Event driven architecture
using Kafka
4. Key Benefits from Confluent
5. How we do it?
6. Q&A

20. Confluent Cloud
Cloud-native data streaming platform built
by the founders of Apache Kafka®
Everywhere
Connect your data in real
time with a platform that
spans from on-prem to
cloud and across clouds
Complete
Go above & beyond Kafka
with all the essential tools
for a complete data
streaming platform
Cloud-Native
Apache Kafka©, fully
managed and re-
architected to harness
the power of the cloud
Stream confidently on the world’s most trusted data streaming platform built by the founders of
Apache Kafka©, with resilience, security, compliance, and privacy built-in by default.
2
0

21. …enabling you to deploy, operate, and scale in
minutes instead of months
Kafka re-architected to be truly Cloud-Native
2
1
Months Minutes
Weeks
Open Source
Apache Kafka
In-house development and
maintenance without support
Self-managed
Kafka Services
Manual operations with basic
tooling and/or support
Confluent
Cloud
Fully managed, elastic,
and automated product
capabilities with zero overhead

22. Free trial of Confluent Cloud
22

23. Why Confluent?
Schema Registry: Eliminate interservice
bottlenecks and dependencies, with a
centralized schema repository
Confluent Cloud: Remove the operational
hassles for cluster management, with a
cloud-native service
ksqlDB: Build real-time contextual
applications, with an event-streaming
database
Increase Developer Velocity
1

24. Schema Registry: Eliminate interservice
bottlenecks and dependencies, with a
centralized schema repository
Confluent Cloud: Remove the operational
hassles for cluster management, with a
cloud-native service
ksqlDB: Build real-time contextual
applications, with an event-streaming
database
Increase Developer Velocity
1
Build Highly Reliable and
Fault Tolerant Microservices
Infinite Storage: A system for record for
systems and applications
Multi-Region Clusters: Run a single
cluster across multiple DCs for
disaster recovery and high availability
End-to-end Stream Governance:
Discover, understand and trust your data
streams with a fully managed suite
2
Why Confluent?

25. Schema Registry: Eliminate interservice
bottlenecks and dependencies, with a
centralized schema repository
Confluent Cloud: Remove the operational
hassles for cluster management, with a
cloud-native service
ksqlDB: Build real-time contextual
applications, with an event-streaming
database
Increase Developer Velocity
Build Highly Reliable and
Fault Tolerant Microservices
Reduce Technical Debt and
Messaging TCO
Infinite Storage: A system for record for
systems and applications
Multi-Region Clusters: Run a single
cluster across multiple DCs for
disaster recovery and high availability
End-to-end Stream Governance:
Discover, understand and trust your data
streams with a fully managed suite
200+ Connectors: Leverage CDC, JMS and
JDBC connectors to unlock data from
legacy applications
Cluster Linking: Geo-replicate data and
bridge to cloud, by linking clusters across
hybrid and multicloud environments
1 2 3
Committer-driven Expertise: Support
your migration and modernization journey
with our assistance
Why Confluent?

26. Agenda
26
2. Challenges with Monoliths
and Interservice Communication
1. Tenets for Faster Application
Development
3. Event driven architecture
using Kafka
4. Key Benefits from Confluent
5. How we do it?
6. Q&A

27. How we do it:
a Retail Example

28. E-Commerce Application
(Monolith)
2
8
Catalog
Order
Payment
On-Prem Monolith
(E-commerce App)
Load
Balancer
Client/Web
Application
Writes
Reads
Writes
Reads

29. Step 1: Route Reads to
Catalog Microservice
2
9
Catalog
Order
Payment
On-Prem Monolith
(E-commerce App)
Load
Balancer
Client/Web
Application
Writes to
Catalog module
Other Writes
and Reads
Writes
Reads
Writes
CDC Source
Connector
Streams (Reads)
Reads from
Microservice
Partially replaces
Catalog Module
Cloud Native
Catalog Microservice

30. Step 2: Fully Replace
Catalog Module
3
0
Order
Payment
On-Prem Monolith
(E-commerce App)
Load
Balancer
Client/Web
Application
Other Writes
and Reads
Writes
Reads
Writes
CDC Source +Sink
Connector
Cloud Native
Catalog Microservice
Streams (Reads)
Reads from
Microservice
Reads
Streams (Writes)
Writes to
Microservice
Third Party Consumer Apps

31. How we do it?
a Banking Example

32. Banking Reference
Architecture (Traditional)
3
2
Transaction Query Invalid Operation Query
Batch Process
Monolith
Payment Module
Customer
Module
Transaction
Module

33. Step 1. Route Reads to
Payment Microservice
3
3
Payment
Module
Transaction
Module
Monolith
ksqlDB
Payment Stream
Customer Stream
Transaction Stream
Authorization Stream
Invalid Operation
Stream
Schema
Registry
CDC
Connector
JMS
Connector
Customer
Module
Payment
Microservice
Transaction Query Invalid Operation Query

34. Step 2. Fully Replace
Payment Module
3
4
Transaction
Module
Monolith
ksqlDB
Payment Stream
Customer Stream
Transaction Stream
Authorization Stream
Invalid Operation
Stream
Schema
Registry
CDC
Connector
JMS
Connector
Customer
Module
Transaction Query Invalid Operation Query
Payment
Microservice

35. Agenda
35
2. Challenges with Monoliths
and Interservice Communication
1. Tenets for Faster Application
Development
3. Event driven architecture
using Kafka
4. Key Benefits from Confluent
5. How we do it?
6. Q&A

36. Thank you!