Any concept.
clear in 60 seconds.

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

Availability is about access; reliability is about correct performance.

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

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

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

Functional requirements define what a system does, while non-functional requirements define how it performs.

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

Latency, throughput, and response time are key metrics in system performance.

Graceful degradation allows apps to function partially during service failures.

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

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

The USE Method helps find and analyze infrastructure bottlenecks in software systems.

Vertical scaling means upgrading one server, while horizontal scaling means adding more servers.

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

Latency is the time for one request, while throughput is how many requests are processed.

Alerting helps notify the right people about production issues quickly.

SLIs measure service performance, SLOs set reliability targets, and SLAs are customer agreements.

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

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

Fail Fast means stopping quickly on errors, while Fail Safe ensures safety in failures.

Timeouts in distributed systems indicate suspicion, not confirmed failure.

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

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

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

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

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

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

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

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

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

Load balancers distribute traffic across multiple servers to enhance performance and reliability.

Cache penetration occurs when requests for non-existent data overload the database.

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

Database replication enhances data availability and read performance but has challenges like replication lag.

Cascading failures occur when one service's failure impacts others, causing widespread issues.

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

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

An error budget shows how much downtime is acceptable while meeting reliability goals.

A timeout indicates a deadline was exceeded, not necessarily a failure.

A reverse proxy routes client requests to different backend services efficiently.

Logs, metrics, and traces help engineers debug issues in software systems.

Failover ensures systems remain operational by managing leader changes during failures.

DNS resolution translates a URL into an IP address for web access.

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

The Cache-Aside Pattern speeds up data retrieval by using a cache to store frequently accessed data.

REST API design focuses on creating clean, efficient, and scalable web services.

Jitter helps spread out client retries to avoid traffic spikes.

The choice between SQL and NoSQL databases depends on your application's specific needs.

Partial failure means some services fail while others keep running, impacting system reliability.

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

Load shedding helps systems reject excess requests to maintain performance during high demand.

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

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

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

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

Consistency models determine what data reads in distributed systems can see.

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

L4 and L7 load balancers differ in how they route network traffic based on layers of the OSI model.

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

Choose Elasticsearch for complex text searches, but use databases for structured queries.