Any concept.
clear in 60 seconds.

Request-Response asks for a result, while Events notify that something has happened.

The Transactional Outbox Pattern ensures database updates and event publishing are synchronized to avoid losing events.

Microservices can communicate using five key patterns based on their needs.

The Saga Pattern manages distributed transactions using local transactions and compensating actions.

Causality in distributed systems helps understand how events influence each other, beyond just timestamps.

gRPC allows efficient communication between services using a structured request-response model.

Kafka uses state stores to remember previous events in stateful stream processing.

Kafka Schema Evolution allows safe changes to message structures without breaking existing consumers.

Queues distribute tasks to one consumer, while Pub/Sub broadcasts events to multiple subscribers.

Kafka Streams offers higher-level abstractions, while Kafka Consumer provides direct control.

You can replay Kafka events safely by separating live and replay processes.

2-Phase Commit helps maintain data consistency in transactions across multiple databases.

Kafka Streams uses tumbling and hopping windows for time-based data aggregation.

Graceful degradation allows apps to function partially during service failures.

Kafka uses retries and Dead Letter Queues to manage message processing failures.

Lamport Timestamps help order events in distributed systems while preserving causality.

Database per Service ensures each microservice owns its data, reducing dependencies.

In distributed systems, timestamps don't always reflect the true order of events.

Vector clocks help track the order and concurrency of events in distributed systems.

Message queues allow services to communicate asynchronously, improving scalability and reliability.

Kafka consumer reprocessing involves safely replaying events to correct system states.

Search engines collect, index, retrieve, and rank documents to provide relevant results.

A Circuit Breaker helps prevent system failures by stopping calls to unhealthy services.

Stateless servers are easier to scale because they don't store user session data locally.

Older offsets can overwrite newer ones in Kafka if not handled properly.

The Bulkhead Pattern isolates resources to protect critical workloads from failures.

gRPC supports four communication patterns: Unary, Server Streaming, Client Streaming, and Bidirectional Streaming.

Dependency failures can disrupt applications, but resilience patterns can help manage them.

The retry pattern helps systems recover from temporary failures but can cause overload if misused.

FAANG interviewers evaluate problem understanding, architecture, scalability, and communication skills.

An API Gateway simplifies client access to backend services in microservices.

Distributed backpressure helps manage the flow of work between services to prevent overload.

Physical time tells when events happen, while logical time tells their order.

Apache Kafka is a system for managing large volumes of events efficiently.

Backpressure prevents system overload by managing message processing rates in Kafka.

The Circuit Breaker pattern controls service calls to prevent failures from spreading.

Crash failures stop a service, while network failures disrupt communication.

Observability helps engineers understand system behavior to debug production issues effectively.

Fail-stop means a system stops and stays down, while fail-recover means it can come back but needs to be ready.

Kafka can help ensure messages are processed once, but requires careful design.

Backpressure helps manage message flow in Kafka during traffic spikes.

Kafka uses retry topics and delayed retries to manage message failures efficiently.

Elasticsearch distributes search queries across shards to find and retrieve results quickly.

Synchronous communication waits for a response, while asynchronous continues without waiting.

Microservices and modular monoliths differ mainly in deployment and communication methods.

FAANG engineers use high-level design principles to create scalable systems.

Idempotency ensures that repeated operations in APIs do not cause duplicate effects.

Fallbacks allow systems to handle failures safely and maintain user experience.

Monolithic and microservices architectures each have unique advantages and challenges for software development.

HLD provides an overview of system architecture, while LLD details implementation specifics.

Kafka commit strategies determine how offsets are managed during message processing.

Network partitions occur when servers are operational but can't communicate, affecting system performance.

Kafka's commitSync waits for confirmation, while commitAsync continues immediately.

Microservices are useful when you need independent scaling, deployment, and clear boundaries in software design.

Choosing the right boundaries for microservices is crucial for effective architecture.

The CAP Theorem explains the trade-offs in distributed systems during network failures.

Transactions ensure database operations are reliable using ACID properties.

Choosing between a shared database and a database per service affects system design significantly.

Message delivery semantics define how messages are sent in distributed systems and handle failures.

REST, RPC, and gRPC are different methods for communication in software systems.