Interview Q&A

Follow :

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: Ensuring consistency across distributed microservices can be challenging due to the decentralized nature of microservices, each potentially having its own database. Here's how you can approach it:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• Eventual Consistency: In an eventual consistency model, changes to one service

may take time to propagate to others. This model allows for temporary

inconsistencies, but guarantees that, given enough time, all services will eventually

reach a consistent state. This is common in distributed systems because it allows for

better availability and performance.

Example: If an Order Service and Inventory Service are eventually consistent,

when an order is placed, the inventory might not be updated immediately, but it will

be updated eventually once the event is processed.

• Strong Consistency: In a strongly consistent system, once a change is made in one

service (or database), all other services (or databases) will immediately reflect that

change. This model ensures that all services have the same state at any point in time

but often at the cost of performance and availability.

Example: A banking system where an update to a user’s balance must

immediately be reflected across all services to ensure that the balance is never

inconsistent.

Answer: n event or sends a message to the next service. Compensation: If any step in the saga fails, compensating actions (like rolling back previous steps) are executed to maintain consistency. There are two types of sagas:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

The Saga pattern is used to manage long-running transactions in microservices without

requiring a distributed transaction (e.g., two-phase commit). It breaks down a transaction into

Follow :

smaller, isolated steps, with each step running in its own service and completing successfully

or being compensated in case of failure.

• Steps: Each microservice in a saga performs a local transaction and then publishes

an event or sends a message to the next service.

• Compensation: If any step in the saga fails, compensating actions (like rolling back

previous steps) are executed to maintain consistency.

There are two types of sagas:

Answer: The Two-Phase Commit (2PC) protocol is a mechanism to ensure that a distributed transaction is committed successfully across multiple services or databases. It involves two phases:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: Rather than relying on a global transaction manager, microservices can manage distributed transactions using patterns like:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: In distributed systems, network partitions can happen, causing parts of the system to become unreachable or inconsistent. Here's how to deal with them:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

nd when you would need them?

Distributed locks are used in microservices architectures to prevent concurrent access to a

shared resource or data across multiple services. This is critical in cases where multiple

services or instances of the same service need to access shared resources or perform

operations that should be executed in an exclusive manner.

• When to use:
• Critical sections: For example, if multiple services are accessing the same

shared database and you want to ensure that only one service updates a

record at a time.

• Distributed jobs: In cases where multiple instances of a service need to

coordinate a task (e.g., only one instance should be processing a batch job at

time).

• Tools:
• Redis can be used for distributed locking with the SETNX (set if not exists)

command.

• Zookeeper is another popular tool for implementing distributed locks,

llowing services to coordinate actions in a fault-tolerant way.

Distributed locks are used in microservices architectures to prevent concurrent access to a

shared resource or data across multiple services. This is critical in cases where multiple

services or instances of the same service need to access shared resources or perform

operations that should be executed in an exclusive manner.

Follow :

• When to use:
• Critical sections: For example, if multiple services are accessing the same

shared database and you want to ensure that only one service updates a

record at a time.

• Distributed jobs: In cases where multiple instances of a service need to

coordinate a task (e.g., only one instance should be processing a batch job at

a time).

• Tools:
• Redis can be used for distributed locking with the SETNX (set if not exists)

command.

• Zookeeper is another popular tool for implementing distributed locks,

allowing services to coordinate actions in a fault-tolerant way.

Answer: Compensating transactions are used to undo the changes made by a service in a distributed transaction, particularly when one of the services in the transaction fails.

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

n event-driven architecture (EDA) is a design paradigm in which services communicate

by producing, consuming, and reacting to events. In an event-driven architecture, an event

represents a state change or a significant occurrence within the system. This design is

particularly well-suited for microservices because it promotes loose coupling, scalability,

nd asynchronous communication.

How it's used in microservices:

• Asynchronous communication: Microservices emit events (e.g., "Order Created",

"Payment Processed") to signal that something significant has occurred, and other

services react to those events asynchronously. This reduces the direct dependencies

between services.

• Decoupling: Services don't need to know about each other's internal workings. A

service simply listens to events and performs actions accordingly.

• Event brokers like Kafka, RabbitMQ, or Amazon SNS/SQS help to deliver events

between microservices.

Example: In an e-commerce system, when a customer places an order, the Order Service

emits an event like "OrderCreated". The Inventory Service listens to this event and updates

stock levels, and the Shipping Service may start the order fulfillment process.

Answer: nd manages its own events, which makes it easier to decouple services and manage their state independently. How it fits into microservices:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Event Sourcing is a pattern where state changes are not stored directly in a database, but

instead, each state transition (or change) is stored as an event. The state of the system can

be recreated by replaying these events. In a microservices architecture, each service stores

and manages its own events, which makes it easier to decouple services and manage their

state independently.

How it fits into microservices:

Answer: The publish-subscribe pattern allows microservices to communicate asynchronously without knowing about each other. Here's how to implement it:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Pros:

• Asynchronous communication: Message brokers enable non-blocking

communication between services, improving performance and responsiveness.

• Loose coupling: Services don’t need to know about each other’s internals; they only

communicate through events.

• Reliability: Message brokers like Kafka provide persistence and fault tolerance,

ensuring that messages are not lost.

• Scalability: Both Kafka and RabbitMQ can handle a large number of messages and

scale with the load.

• Event-driven architecture: Supports event-driven systems, where services react to

changes in state rather than polling or synchronous calls.

Cons:

• Complexity: Setting up and maintaining message brokers introduces additional

complexity in your system.

• Eventual consistency: With asynchronous communication, the system becomes

eventually consistent, which can complicate data synchronization.

• Performance Overhead: Depending on the system design and message size, there

can be latency due to message delivery, especially if a broker fails or is under heavy

load.

• Operational Overhead: Managing message brokers (e.g., scaling, ensuring

durability, and managing queues) can add operational complexity.

n event-driven state machine is a pattern where the state of an entity is managed and

transitioned based on events in the system. It is useful for modeling workflows that need to

go through various states in response to different events (e.g., order lifecycle, payment

processing).

• States: Each entity (e.g., an order) goes through a series of states, such as

"Pending", "Processing", "Shipped", "Delivered".

• Events: Events trigger state transitions. For example, receiving an "OrderShipped"

event could transition an order from "Processing" to "Shipped".

• State Machine Logic: The state machine ensures that the entity moves through

states in a well-defined manner, preventing invalid state transitions and allowing for

complex workflows.

This pattern helps make business logic explicit and maintainable in event-driven

microservices.

Answer: Managing schema evolution in event-driven systems is crucial to ensure backward compatibility when services evolve over time:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Idempotent event processing means that processing an event multiple times will result in

the same outcome, ensuring that repeated processing doesn't cause issues such as data

corruption or duplication.

Importance in microservices:

• Reliability: In event-driven systems, events may be retried due to failures or

timeouts. Idempotency ensures that retries don’t cause inconsistent data.

• Resilience: Services can safely process events without worrying about duplication,

ensuring system stability during network or processing failures.

• Consistency: Helps maintain data consistency across microservices even when

events are delivered multiple times due to failures or retries.

To implement idempotency, use unique identifiers for events, and ensure that the service

checks if the event has been processed before performing any action.

Data Storage and Management

Answer: pplication? Choosing the right database for a microservices application depends on various factors:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: Choosing the right database for a microservices application depends on various factors:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

pplication based on the specific needs of each service. In a microservices architecture,

each service can have its own database optimized for its particular requirements, making it

more efficient and scalable.

• Relevance in Microservices:
• Decentralization: Each microservice can pick the most appropriate database

(SQL, NoSQL, graph database, etc.) depending on its data structure, access

patterns, and consistency requirements.

• Flexibility: It enables each service to evolve independently with the database

best suited for its domain, avoiding the complexity of fitting all services into a

single database model.

• Scalability: Microservices can scale their databases independently, choosing

specialized databases for specific workloads (e.g., NoSQL for unstructured

data, SQL for transactional data).

Polyglot persistence refers to the use of multiple different types of databases within an

application based on the specific needs of each service. In a microservices architecture,

each service can have its own database optimized for its particular requirements, making it

more efficient and scalable.

• Relevance in Microservices:
• Decentralization: Each microservice can pick the most appropriate database

(SQL, NoSQL, graph database, etc.) depending on its data structure, access

patterns, and consistency requirements.

• Flexibility: It enables each service to evolve independently with the database

best suited for its domain, avoiding the complexity of fitting all services into a

Follow :

single database model.

• Scalability: Microservices can scale their databases independently, choosing

specialized databases for specific workloads (e.g., NoSQL for unstructured

data, SQL for transactional data).

SQL (Relational) Databases:

• Structure: Data is stored in structured tables with defined relationships (tables, rows,

columns).

• Consistency: Typically follows ACID (Atomicity, Consistency, Isolation, Durability)

properties for transaction integrity.

• Use cases:
• Strong consistency and complex querying needs.
• Relational data with complex relationships (e.g., financial systems, inventory

systems).

• Well-suited for applications requiring complex joins and aggregations.

NoSQL (Non-relational) Databases:

• Structure: Data is stored in various formats (key-value, document, column-family, or

graph).

• Consistency: Often uses eventual consistency, trading off strict consistency for

availability and partition tolerance (CAP theorem).

• Use cases:
• High scalability and flexibility (e.g., social media applications, logging

systems).

• Unstructured or semi-structured data (e.g., JSON in MongoDB).

Follow :

• High throughput and horizontal scalability (e.g., Cassandra for large-scale

data).

In Microservices:

• SQL databases are often used for transactional services that need to enforce ACID

properties, while NoSQL is used for services that need high scalability, flexible

schema, or eventual consistency (e.g., MongoDB, Cassandra).

Answer: Handling database transactions across microservices is challenging because each microservice typically has its own database, making traditional monolithic transactions (ACID) unsuitable. Here are some approaches:

What interviewers expect

• A clear definition tied to Microservices in Microservices projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Microservices application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Microservices architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.