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.

Authentication verifies who you are, while authorization determines what you can do.

N+1 redundancy means having one extra server to maintain capacity during a failure.

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.

Fault domains help prevent multiple servers from failing together in an architecture.

Stream Processing Architecture helps turn incoming events into real-time insights efficiently.

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.

High Availability ensures your application remains operational even during server failures.

Alerting helps notify the right people about production issues quickly.

Batch processing collects data to process later, while stream processing handles data in real-time.

OLTP handles transactions while OLAP is for data analysis and reporting.

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.

CQRS separates how we change data from how we read data, improving scalability.

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.

Event time is when an event occurs, while processing time is when it is handled.

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.

Containers share the host OS kernel, while VMs virtualize hardware with separate OS.

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.

Availability Zones help prevent downtime by isolating failures across multiple locations.

Downsampling and aggregation reduce data volume while preserving essential trends.

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.

Time-series databases are designed to store and query time-stamped metrics efficiently.

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.