Back-end Web Developement Performance Optimization Syllabus

Distinguish a CDN cache HIT, MISS, and origin fetch.

A HIT means the edge serves content directly from its cache. A MISS means the edge lacks the content, so it fetches from the origin (or an upstream tier), caches it, then serves it. The origin fetch adds latency only on the miss.

What is cache invalidation / purging in a CDN?

Purging (invalidation) removes or marks stale specific cached objects at the edge so the CDN re-fetches fresh content from the origin. It is used when content changes before its TTL expires.

What HTTP header primarily controls how long a CDN/browser caches an object?

The Cache-Control header (e.g., max-age, s-maxage, no-cache, private/public). s-maxage specifically targets shared caches like CDNs; Expires and ETag also influence caching and revalidation.

What is load balancing, and why is it needed?

Load balancing distributes incoming network/application traffic across multiple backend servers. It prevents any single server from being overloaded, improves throughput and response time, and increases availability and fault tolerance.

Describe the Round Robin load-balancing algorithm.

Round Robin assigns each incoming request to the next server in a cyclic sequence: server 1, 2, 3, ..., n, then back to 1. It distributes requests evenly by count, ignoring current server load or connection count.

For n servers under Round Robin, which server handles request number k (1-indexed)?

$$\text{server} = ((k - 1) \bmod n) + 1$$ so requests cycle through the servers $1, 2, \dots, n, 1, 2, \dots$

What is the main limitation of plain Round Robin load balancing?

It assumes all servers have equal capacity and all requests cost the same. It ignores actual load, active connections, and response times, so heterogeneous servers or uneven request costs can cause imbalance.

Describe Weighted Round Robin and its purpose.

Weighted Round Robin assigns each server a weight proportional to its capacity; higher-weight servers receive proportionally more requests within each cycle. It handles heterogeneous server capacities that plain Round Robin cannot.

In Weighted Round Robin, what fraction of traffic does server i with weight $w_i$ receive?

$$\text{fraction}_i = \frac{w_i}{\sum_{j=1}^{n} w_j}$$

Describe the Least Connections load-balancing algorithm.

Least Connections routes each new request to the server currently handling the fewest active connections. It adapts to real-time load and suits long-lived or variable-duration connections better than Round Robin.

When is Least Connections preferable to Round Robin?

When requests have widely varying durations or resource costs (e.g., long-lived sessions, streaming, WebSockets). Least Connections balances by actual concurrent load rather than raw request count, avoiding pile-up on slow servers.

What is Weighted Least Connections?

A variant that selects the server minimizing the ratio of active connections to its weight (capacity), i.e., it picks the server with the smallest $\frac{\text{active connections}_i}{w_i}$, combining real-time load with server capacity.

Describe the IP Hash load-balancing algorithm.

IP Hash computes a hash of the client's source IP address (sometimes source+destination) and uses it to deterministically select a backend server. The same client IP consistently maps to the same server, providing session affinity (sticky sessions).

For IP Hash across n servers, express which server a client is assigned to.

$$\text{server} = \text{hash}(\text{client IP}) \bmod n$$ mapping the hashed IP deterministically to one of the $n$ servers.

What is the primary advantage and the primary drawback of IP Hash?

Advantage: session persistence without shared session storage, since a client always reaches the same server. Drawback: uneven distribution if client IPs cluster (e.g., behind NAT/proxies), and remapping when the server count $n$ changes (unless consistent hashing is used).

Why does consistent hashing improve on plain modulo IP Hash when servers are added or removed?

With plain $\text{hash} \bmod n$, changing $n$ remaps almost all keys. Consistent hashing places servers and keys on a hash ring so that adding/removing a server only remaps about $\frac{1}{n}$ (K/n) of the keys, minimizing cache/session disruption.

Classify Round Robin, Least Connections, and IP Hash as static or dynamic algorithms.

Round Robin and IP Hash are static (decisions based on fixed rules/hashing, not live server state). Least Connections is dynamic (decisions based on real-time active-connection counts).

What is New Relic, and what category of tool is it?

New Relic is a commercial SaaS observability and Application Performance Monitoring (APM) platform. It collects metrics, traces, logs, and events from applications and infrastructure to monitor performance, errors, and user experience.

What is Apdex, the score New Relic uses, and give its formula.

Apdex (Application Performance Index) measures user satisfaction with response times against a target threshold $T$. $$\text{Apdex}_T = \frac{\text{Satisfied} + \frac{\text{Tolerating}}{2}}{\text{Total Samples}}$$ where satisfied requests are $\leq T$, tolerating are $> T$ and $\leq 4T$, and frustrated are $> 4T$.

What is the range of an Apdex score and what does 1 mean?

Apdex ranges from $0$ to $1$. A score of $1$ means every request was 'satisfied' (all within the target threshold $T$); $0$ means every user was frustrated.

Name three telemetry types (the 'pillars of observability') that platforms like New Relic collect.

Metrics, Logs, and Traces (often summarized as MELT: Metrics, Events, Logs, Traces). Together they give a full view of system behavior and performance.

What is Prometheus, and what monitoring model does it use?

Prometheus is an open-source (CNCF) monitoring and alerting toolkit that stores time-series metrics. It uses a pull-based model: the Prometheus server scrapes metrics over HTTP from instrumented targets/exporters at defined intervals.

What query language does Prometheus use, and what is it for?

PromQL (Prometheus Query Language). It is a functional language for selecting, aggregating, and computing over time-series data to produce graphs, tables, and alerting rules.

Name the four core Prometheus metric types.

Counter (monotonically increasing), Gauge (can go up or down), Histogram (bucketed observations with counts), and Summary (client-side quantiles). Counters and gauges are scalar; histograms and summaries track distributions.

In PromQL, what does the rate() function compute over a counter, e.g. $\text{rate}(http\_requests\_total[5m])$?

It computes the per-second average rate of increase of the counter over the specified time window (here 5 minutes), automatically handling counter resets. It answers 'how many requests per second on average.'

What is a Prometheus 'exporter'?

An exporter is a component that exposes metrics from a third-party system (e.g., databases, hardware, OS) in Prometheus format on an HTTP endpoint so the Prometheus server can scrape them. Example: node_exporter for host metrics.

What component handles alert routing/notification in the Prometheus ecosystem?

Alertmanager. Prometheus evaluates alerting rules and fires alerts to Alertmanager, which deduplicates, groups, silences, and routes notifications to receivers like email, Slack, or PagerDuty.

What is Grafana, and what is its primary role?

Grafana is an open-source analytics and visualization platform. It connects to data sources (like Prometheus, Loki, InfluxDB, SQL databases) and renders interactive dashboards, graphs, and alerts. Its main role is visualization, not storage.

How do Prometheus and Grafana typically work together?

Prometheus collects and stores time-series metrics and is added as a data source in Grafana. Grafana queries Prometheus (via PromQL) to build dashboards and visualizations. Prometheus = collection/storage; Grafana = visualization/dashboards.

Given a service with throughput 500 requests/second and average concurrency (requests in system) of 50, use Little's Law to find the average response time.

Little's Law: $L = \lambda W$, so $W = \frac{L}{\lambda}$. $$W = \frac{50}{500} = 0.1\ \text{s} = 100\ \text{ms}$$

State Amdahl's Law for speedup and explain what it bounds.

$$S = \frac{1}{(1 - p) + \frac{p}{s}}$$ where $p$ is the parallelizable/optimizable fraction and $s$ its speedup. It bounds overall speedup: even as $s \to \infty$, $S \to \frac{1}{1-p}$, so the serial fraction limits total performance gains.