Interview Q&A

rchitecture?

Domain-Driven Design (DDD) helps structure microservices around business domains. It

emphasizes:

• Bounded Contexts: Microservices align with natural business boundaries.
• Ubiquitous Language: Ensures a shared understanding of business concepts

cross the team.

• Aggregates: Group entities that are naturally consistent together under a single

service boundary.

• Context Mapping: Defines how different microservices interact with each other.

DDD provides the foundation for designing and organizing microservices based on

real-world business requirements.

Domain-Driven Design (DDD) helps structure microservices around business domains. It

emphasizes:

• Bounded Contexts: Microservices align with natural business boundaries.
• Ubiquitous Language: Ensures a shared understanding of business concepts

across the team.

• Aggregates: Group entities that are naturally consistent together under a single

service boundary.

• Context Mapping: Defines how different microservices interact with each other.

DDD provides the foundation for designing and organizing microservices based on

real-world business requirements.

Follow :

• API Gateway: An API Gateway acts as an entry point for client requests, routing

them to the appropriate microservices. It handles authentication, rate limiting, load

balancing, and response aggregation.

Example: An API Gateway could route a request for placing an order to both the

Order Service and Payment Service.

• Service Mesh: A service mesh manages communication between microservices

themselves. It provides service discovery, traffic management, security, and

monitoring.

Example: A service mesh like Istio helps microservices communicate securely and

ensures traffic routing, retries, and circuit breaking without changing application code.

• Large Teams: When multiple teams need to work independently on different parts of

the system.

• Scalability Needs: If certain parts of the application require more resources or

scaling than others.

• Frequent Releases: Microservices enable faster release cycles for specific features

or services.

• Resilience: When you need to isolate failures to prevent affecting the entire system.
• Technological Diversity: If different services have different technology needs (e.g.,

different databases or frameworks).

In contrast, monolithic architectures might be more suitable for smaller applications or when

development speed and simplicity are top priorities.

Service Communication

request to another service and waits for the response before continuing with its

processing. The service that sends the request is blocked until it receives a response

from the other service. This is typically used for real-time communication, like

RESTful APIs over HTTP.

Example: A User Service might request the Payment Service to verify a payment

before processing an order. The User Service waits until it receives the response.

• Asynchronous Communication: In asynchronous communication, one service

sends a request to another service but does not wait for a response. The requesting

service continues processing while the service handling the request processes it in

the background. This is typically used in event-driven architectures with message

brokers.

Example: An Order Service might send a message to a queue (via RabbitMQ or

Kafka) about a new order, and the Inventory Service processes it at its own pace,

independently of the Order Service.

• Synchronous Communication: In synchronous communication, one service sends

a request to another service and waits for the response before continuing with its

processing. The service that sends the request is blocked until it receives a response

from the other service. This is typically used for real-time communication, like

RESTful APIs over HTTP.

Example: A User Service might request the Payment Service to verify a payment

before processing an order. The User Service waits until it receives the response.

• Asynchronous Communication: In asynchronous communication, one service

sends a request to another service but does not wait for a response. The requesting

service continues processing while the service handling the request processes it in

the background. This is typically used in event-driven architectures with message

brokers.

Example: An Order Service might send a message to a queue (via RabbitMQ or

Kafka) about a new order, and the Inventory Service processes it at its own pace,

independently of the Order Service.

To handle communication between microservices using RESTful APIs:

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.

To implement event-driven architecture in 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.

Answer: Service discovery allows microservices to automatically detect and connect to each other without hardcoding IP addresses or hostnames. There are two main ways to implement service discovery:

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 Circuit Breaker pattern helps prevent a failure in one part of the system from

cascading and affecting other parts of the system. It monitors requests to a service and trips

the circuit (i.e., stops further calls) when the service is deemed unhealthy.

• States of Circuit Breaker:

Follow :

• Closed: The circuit is "closed" and requests are passed through to the

service.

• Open: If the service fails repeatedly, the circuit "opens," and further requests

are not sent to the service, preventing additional strain.

• Half-Open: After a period of time, the circuit breaker enters a half-open state

and allows a few test requests to determine if the service is healthy again.

Implementation: Tools like Hystrix or Resilience4j can be used to implement circuit

breakers. These libraries allow you to specify when a circuit breaker should open based on

service failure rates or response times.

Example: If a Payment Service is down, the circuit breaker will prevent the Order Service

from continuously trying to contact it and instead return a fallback response, reducing strain

on the system.

Follow :

Idempotency ensures that making the same API call multiple times has the same effect,

i.e., it does not cause unintended side effects or inconsistencies. It is crucial in microservices

because:

• Fault Tolerance: In a distributed system, a service may receive the same request

multiple times due to retries or network issues. Idempotency ensures that these

repeated requests do not result in duplication or errors.

• Consistency: It ensures that the system remains in a consistent state, even if a

request is accidentally repeated.

Example: A Payment Service processing the same payment request multiple times due to

a network retry would not result in multiple charges because the API is designed to ignore

duplicate requests with the same unique transaction ID.

API Design & Security

Answer: n API Gateway is a server that acts as an entry point into a microservices architecture. It provides a single point of entry for client applications to interact with multiple microservices. Functions of an API Gateway:

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: PI versioning ensures that changes to an API do not break backward compatibility, which is crucial in a microservices architecture where multiple teams may be consuming services. Strategies for API Versioning:

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.

• OAuth: OAuth is an open standard for access delegation, commonly used to grant

limited access to third-party applications without exposing user credentials. OAuth

provides a token-based approach to secure APIs.

• Authorization Flow: OAuth typically involves three parties—Resource

Owner (user), Client (application), and Authorization Server (auth

provider)—that work together to issue access tokens.

• JWT: JSON Web Tokens (JWT) are compact, URL-safe tokens used to securely

transmit information between parties. JWT tokens are signed and optionally

encrypted to protect the integrity and confidentiality of the data.

• Structure: JWT consists of three parts—Header, Payload, and Signature.

How to use them in microservices:

Answer: In a microservices architecture, handling authentication and authorization can be complex due to the distributed nature of the system. 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.

To secure sensitive data between 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.

CORS (Cross-Origin Resource Sharing) is a security feature implemented by browsers that

prevents web applications from making requests to a domain different from the one that

served the web page.

In a microservices architecture, services may need to communicate across different

domains. Here’s how you can handle CORS:

To secure microservices endpoints, consider the following strategies:

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.

To handle rate-limiting and throttling in a microservices environment:

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: rchitecture? In a distributed microservices architecture, ensuring data consistency is challenging due to the decentralized nature of the system. There are two main types of consistency models:

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 a distributed microservices architecture, ensuring data consistency is challenging due to the decentralized nature of the system. There are two main types of consistency models:

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 is a model in distributed systems where, instead of guaranteeing

immediate consistency across all nodes, the system guarantees that, given enough time, all

replicas will converge to the same state.

In microservices:

• Services might have their own databases, and instead of synchronizing them in

real-time, they propagate updates asynchronously (via events).

• Eventual consistency allows for better system performance and scalability but

introduces the risk of temporary data inconsistencies.

Example: A Shipping Service might be updated with a new order status after the Order

Service has processed the order. However, there may be a short window where the two

services have inconsistent data. Eventually, the system converges to a consistent state.

ccordingly (decoupled).

• Orchestration: A central orchestrator (e.g., a Saga Orchestrator) directs the saga,

ensuring each step is performed and compensation is handled if something fails.

When to use it:

• Long-running workflows that span multiple microservices.
• When you need to ensure that if a service fails, the changes made by previous

services are rolled back.

Example: In an Order Management System, if an order involves creating an order,

processing payment, and updating inventory, the Saga pattern ensures each step completes

successfully. If any step fails, compensation transactions (like refunding payment) are

triggered.

The Saga pattern is a design pattern for managing long-running distributed transactions in

microservices, especially in the context of eventual consistency. It breaks a large transaction

into a series of smaller, isolated transactions that are coordinated through a sequence of

events.

• Choreography: Each service involved in the saga listens for events and takes action

accordingly (decoupled).

• Orchestration: A central orchestrator (e.g., a Saga Orchestrator) directs the saga,

ensuring each step is performed and compensation is handled if something fails.

When to use it:

• Long-running workflows that span multiple microservices.

Follow :

• When you need to ensure that if a service fails, the changes made by previous

services are rolled back.

Example: In an Order Management System, if an order involves creating an order,

processing payment, and updating inventory, the Saga pattern ensures each step completes

successfully. If any step fails, compensation transactions (like refunding payment) are

triggered.

Answer: In a microservices architecture, handling distributed database transactions requires solutions that span across services, since each service typically owns its own database. Here are common strategies:

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.