Lyft Full-Stack Developer (Junior Level) Interview Preparation Guide

Direct answer

Storing a JWT (JSON Web Token) in localStorage or sessionStorage makes it fully readable by any JavaScript running on the page, so it is directly exposed to cross-site scripting (XSS, an attack where malicious script gets injected into and executes on your page); storing it in an HttpOnly, Secure, SameSite cookie keeps it invisible to page script entirely, but a cookie is sent automatically by the browser, which reopens cross-site request forgery (CSRF, an attack that tricks a victim's browser into making an unwanted authenticated request) unless mitigated. For a modern single-page application (SPA), the best-practice combination is neither extreme alone: pair an HttpOnly/Secure/SameSite cookie with a same-site CSRF defense, and for a truly framework-agnostic API split across separately deployed domains, use a backend-for-frontend (BFF) that holds the token server-side entirely and only ever gives the browser an HttpOnly session cookie of its own.

Structured elaboration

Token theft as its own vector, distinct from a live exploit. XSS and CSRF both describe an attacker actively exploiting a running page; token theft can also happen without either, through a channel that simply reads the token value at rest: a malicious or compromised browser extension with broad page-content permissions, a shared or public machine where storage is left readable after the user walks away, or a device-level compromise. HttpOnly closes the script-readable-storage version of this (an extension's injected content-script and an XSS payload are both just script, and both are blocked from reading an HttpOnly cookie), but it does not help against a device already fully compromised at the OS level; no client-side storage choice can fully close that door, which is why short token lifetimes and server-side revocation remain the backstop regardless of where the token is stored.

SameSite policy. SameSite=Strict never sends the cookie on a cross-site navigation or request, the strongest setting but occasionally breaking legitimate cross-site flows (e.g. arriving via a link from another site and expecting to already be logged in); SameSite=Lax (the modern browser default) sends it on top-level navigations but not on cross-site subresource requests or non-GET requests, a reasonable middle ground for most session cookies; SameSite=None (requiring Secure) disables the protection entirely and is only appropriate when the cookie must genuinely be sent cross-site, such as a third-party embedded widget, which should be treated as a deliberate, reviewed exception rather than a default.

CORS considerations. Cross-origin resource sharing (CORS) governs whether a browser lets a page on one origin read a response from another; when the API and the SPA are on different origins and the SPA needs the browser to attach the auth cookie automatically, the request must be made with credentials included (credentials: 'include' client-side) and the server's CORS response must set Access-Control-Allow-Credentials: true alongside an explicit (not wildcard) Access-Control-Allow-Origin naming the SPA's exact origin; a wildcard origin is rejected by browsers for credentialed requests specifically to prevent any site from silently riding on another user's cookies.

Best-practice recommendation for a modern SPA. When the SPA and API share a registrable domain (e.g. app.example.com calling api.example.com), an HttpOnly/Secure/SameSite=Lax cookie plus a CSRF token on state-changing requests is the standard, well-supported baseline. When the frontend is served from an entirely separate deployment (a CDN-hosted SPA calling a third-party or separately-owned API domain), the stronger pattern is a backend-for-frontend: a thin server-side component, deployed on the SPA's own origin, that performs the OAuth/OIDC (OpenID Connect) flow itself, holds the access and refresh tokens server-side (never exposing them to the browser at all), and issues the browser only its own HttpOnly, Secure, SameSite=Strict session cookie scoped to that same origin. The browser never sees a JWT in either case; it only ever holds an opaque session cookie, which sidesteps the localStorage-XSS exposure question entirely rather than trying to mitigate it.

Worked example

A SPA at app.example.com calls an API at api.example.com. Without a BFF, the SPA's JavaScript must hold the access token somewhere to attach it as an Authorization header, since a cross-origin cookie set by api.example.com cannot be read or automatically attached by a page served from app.example.com under a strict same-site policy without extra cross-origin cookie configuration; this pushes many teams toward localStorage, which is exactly the exposure this analysis warns against. With a BFF deployed on app.example.com itself (e.g. app.example.com/bff/*), the browser talks only to its own origin: the BFF holds the real access/refresh tokens server-side, sets a same-origin HttpOnly cookie for the browser, and proxies authenticated calls to api.example.com using the tokens it holds internally. No JavaScript on the page, injected or otherwise, ever has anything to read.

Trade-offs and pitfalls

The BFF pattern's honest cost is operational: it is another deployed component with its own availability and latency to manage, which is real overhead for a small team, not a free upgrade. Relying on SameSite alone without any CSRF token is a common shortcut that mostly works in modern browsers but leaves a gap for the (shrinking, but real) population of clients or embedded contexts that do not fully enforce it; defense in depth (both SameSite and an explicit CSRF token) is worth the modest extra code for anything handling sensitive actions. The most common outright mistake is storing the access token in localStorage purely for developer convenience, because it is simpler to attach manually to requests, without weighing that a single XSS vulnerability anywhere in the application (including in a third-party script or dependency) then compromises every session, not just the vulnerable page.

Direct answer
Write a short summary right after the meeting that states the decision made, names an owner and deadline for each follow-up, and flags anything still unresolved, so nobody has to reconstruct what happened from memory a week later.

Structured elaboration

1. State the decision first, in one sentence, even if it feels obvious right after the meeting; it stops being obvious within a day or two, especially for people who weren't in the room.
2. List action items with an owner and a deadline each, not a bare to-do list; "someone should look into X" is not actionable, "Priya will check the vendor SLA by Thursday" is.
3. Name what's still open, explicitly, rather than letting it quietly drop; a one-line "not yet decided: whether we notify customers proactively" prevents someone assuming it was implicitly settled.
4. Send it promptly, ideally within the hour, while the details are fresh and before people have moved on to something else and stopped tracking it mentally.
5. Keep it short. Three to six sentences is usually enough; a summary that's as long as a transcript won't get read.

Worked example
"Decision: we're moving the schema migration to next Tuesday's low-traffic window instead of doing it live this week. Action items: Priya to update the migration runbook by Monday EOD; Sam to notify the on-call rotation of the new window by Friday. Open question: whether we need a customer-facing heads-up, still deciding, will confirm by Wednesday."

Three sentences, one decision, two owned action items with deadlines, and one explicitly flagged open item.

Trade-offs and pitfalls

• The most common failure is writing a summary that lists what was discussed instead of what was decided; a meeting can generate a page of discussion and one real decision, and the summary should reflect that ratio.
• An action item without a named owner tends to silently not get done; if you can't name an owner in the summary, that's a sign the meeting didn't actually resolve who's responsible.
• Sending it too late (days later) defeats the purpose; by then people have already formed their own, sometimes conflicting, memory of what was agreed.

Quick framing (Full‑stack view)
Choose by how your app tolerates stale reads, global latency requirements, team ops capacity, and budget predictability.

AWS RDS + Read Replicas

• Consistency: Primary is strong; replicas are eventual — reads can be stale.
• Latency: Low for writes in primary region; global reads faster if near replicas.
• Operational burden: Managed backups/patching; still DB engine upgrades, replica failover logic.
• Cost: Instance + storage + cross‑AZ/region replication costs; predictable but scales with instances.
• Lock‑in: Moderate (SQL portability), migration effort for engine-specific features.

DynamoDB Global Tables

• Consistency: Multi‑master async by default; offers strongly consistent reads per region only. Cross‑region strong consistency not native.
• Latency: Very low read/write in local region.
• Ops burden: Minimal (serverless).
• Cost: Pay-per-request + storage + replication traffic; can be expensive at high write rates.
• Lock‑in: High (proprietary APIs), but good SDK support.

Google Cloud Spanner

• Consistency: Global strong consistency and distributed transactions.
• Latency: Low for local reads, writes may incur cross‑region RTTs depending on config.
• Ops burden: Low (managed), but schema and performance tuning required.
• Cost: High and usage-based (nodes); predictable at scale.
• Lock‑in: High (Spanner-specific SQL/DDL), but great for transactional global apps.

Self‑managed CockroachDB

• Consistency: Strong (Raft), geo‑partitioning possible.
• Latency: Tunable; colocate ranges to reduce latency but cross‑region writes incur RTT.
• Ops burden: High — you run clusters, upgrades, monitoring, backups.
• Cost: Infrastructure + engineering time; can be cheaper raw but hidden ops cost.
• Lock‑in: Low (Postgres-compatible SQL), easier to move.

Recommendation: For a small full‑stack team needing minimal ops and predictable global strong consistency → Spanner. For serverless low‑ops with high read locality → DynamoDB. If you need SQL and moderate ops → RDS with replicas. If you control infra and want Postgres‑compat with strong consistency → CockroachDB.

Approach (brief)
Use cursor = encoded (created_at, id) so ordering is deterministic: ORDER BY created_at DESC, id DESC. Cursor opaque token = base64(JSON.stringify({ created_at, id })). Validate/expire server-side.

SQL for loading older messages

-- given cursor (cursor_time, cursor_id)
SELECT id, created_at, content
FROM messages
WHERE (created_at < $1 OR (created_at = $1 AND id < $2))
ORDER BY created_at DESC, id DESC
LIMIT $3;

Plain English: fetch rows strictly older than the cursor; tie-break by id to avoid duplicates/missing when created_at equals.

Express endpoint (example)

// decodeCursor/encodeCursor helper uses base64 JSON
app.get('/messages', async (req, res) => {
  const { cursor, limit = 20 } = req.query;
  let cursorTime = new Date(); let cursorId = 'ffffffff-ffff-...';
  if (cursor) {
    const { created_at, id } = JSON.parse(Buffer.from(cursor, 'base64').toString());
    cursorTime = created_at; cursorId = id;
  }
  const rows = await db.query(SQL_above, [cursorTime, cursorId, limit]);
  const nextCursor = rows.length ? Buffer.from(JSON.stringify({ created_at: rows[rows.length-1].created_at, id: rows[rows.length-1].id })).toString('base64') : null;
  res.json({ messages: rows, nextCursor });
});

Handling deletions between pages

• Deletions simply mean fewer results; cursor still references last seen row.
• If a cursor points to a deleted row, use the next-most-recent row: encode the last returned row (server already does this). Alternatively, include a server-side tombstone look-up fallback: if cursor row missing, treat cursor as the next-latest timestamp/id.
• Inform client: expect occasional page with fewer items; use id set on client to dedupe and reconcile (merge by id).

Notes / Best practices

• Sign/encrypt cursor for tamper-proofing.
• Keep limit bounded and validate input.
• Index on (created_at DESC, id DESC) for performance.

Direct answer

Treat "legal needs three weeks but the team wants one week" as a scope problem, not a speed problem. Split the release into what can ship without new legal review and what genuinely needs sign-off, then give legal a narrow, well-defined ask for the second piece instead of asking them to review everything faster. The team ships on time, and the risky piece launches on its own review-driven schedule.

Structured elaboration

Find out what is actually blocking legal

"Legal sign-off" is rarely one undivided review. Ask legal directly which specific elements are new or unreviewed, and which are unchanged from something already approved. Most releases are a mix, and the review clock usually belongs to a small fraction of the surface area.

Split the release along that line

Everything that reuses already-approved language, patterns, or flows ships in the one-week window. Anything net-new that legal has not seen goes behind a feature flag (a toggle that keeps new code hidden from users until you're ready to turn it on) and ships later, once sign-off lands, decoupled from the original deadline.

Reduce legal's per-item cost, do not just ask for speed

A vague "please review this flow" invites a slow, open-ended read. A redlined diff (a side-by-side markup showing exactly which words changed from the last approved version, like tracked changes) against previously-approved language, with a one-paragraph explanation of what changed and why, is something legal can turn around fast because the review surface is small and explicit.

Keep everyone honest about the split

Do not quietly ship around legal's concern and call it done. Tell legal what you are shipping now, what is gated, and why you drew the line there, and let them confirm or push back on the boundary itself, not just react to a missed deadline.

Worked example

A signup redesign is due in one week. It includes a new consent checkbox asking users to opt into sharing data with a third-party analytics partner, and the copy for that checkbox has never been reviewed (legal quotes three weeks because it touches data-sharing language that needs a compliance read). Everything else in the redesign, the new layout and the reworked field order, is unchanged from an already-approved pattern used elsewhere in the product.

The split: ship the redesign now using the existing, already-approved consent copy and opt-in behavior unchanged. Put the new third-party-sharing consent language and checkbox behind a flag, off by default. Send legal a one-page diff: exactly the new sentence, what data it covers, and why it is being added, instead of the whole signup flow. The redesign ships in the one-week window. The new consent copy ships later, whenever legal actually signs off, on its own timeline, without ever having blocked the rest of the release.

Trade-offs and pitfalls

A flag-gated split adds real overhead: someone has to remember to remove the flag, and a half-shipped feature can linger longer than planned if nobody owns closing the loop. It also only works when the risky piece is genuinely separable. If the new element is load-bearing, meaning the whole flow depends on it, forcing a split creates a worse product than waiting.

The biggest pitfall is doing the split unilaterally and only telling legal afterward. That reads as shipping around the reviewer even when the intent was reasonable, and it burns the relationship needed for the next time this happens. The senior move is proposing the boundary and getting legal's explicit agreement on it before the ship date, not after.

Approach summary (full‑stack view)
For a read-heavy user-profile endpoint with occasional updates, use a layered cache: client -> CDN/edge -> server cache (Redis) -> in-memory LRU on app. Combine conditional requests (ETag) + Cache-Control with stale-while-revalidate to optimize latency while preserving freshness.

Where to cache

• Client (browser): short-lived cache + ETag/If-None-Match so conditional GETs avoid full payloads.
• CDN/Edge: primary for global low-latency; cache by user-id path, respect Cache-Control, support purge APIs.
• Server (Redis): authoritative shared cache for fast reads and TTL-based invalidation.
• App memory: LRU for hottest objects to reduce Redis hops.

Headers & conditional fetches

• ETag + If-None-Match: enable 304 responses so CDN/browser validate cheaply.
• Cache-Control: e.g., "public, max-age=30, stale-while-revalidate=60, stale-if-error=300". Short max-age keeps freshness; stale-while-revalidate lowers latency.

Invalidation patterns

• On profile update: write-through to DB + update/evict Redis and call CDN purge or send cache-control revalidation header.
• Pub/Sub (Redis/MessageQueue): push purge messages to app instances and edge invalidation jobs.
• Soft vs hard TTL: soft TTL (short) triggers background refresh; hard TTL enforces expiry.

TTL choices & balance

• Choose short max-age (10–60s) for user-facing pages where slight staleness is acceptable; use stale-while-revalidate to serve stale instantly while refreshing in background. For sensitive fields (email, privacy settings) use immediate invalidation and shorter TTL.
• Monitor metrics (hit rate, 95th p95 latency, staleness incidents) and tune.

Additional tactics

• Optimistic client update after user edits to improve UX.
• Use conditional CDN purges for big changes; otherwise rely on ETag validation to minimize bandwidth.

Approach

Trace what actually blocks the page from being usable before picking a side, since page load time is a chain, and lazy-loading (deferring resources until needed) and code-splitting (breaking a large JavaScript bundle into smaller pieces loaded on demand) fix a different part of that chain than API aggregation (combining multiple backend calls into fewer round trips).

Worked estimate (illustrative numbers)

Say a trace shows the page currently loads in 4.5 seconds: about 1.5 seconds comes from a chain of 8 sequential API calls at roughly 180 milliseconds round trip each, about 2 seconds from downloading, parsing, and running a large, unsplit JavaScript bundle, and the remaining second from rendering and images.

Aggregating those 8 calls into 2 combined calls could plausibly cut that 1.5 seconds down to 400 to 500 milliseconds, roughly a 1 second win. Code-splitting the bundle so only what is needed for first paint loads up front could plausibly cut the 2 second JavaScript cost by half or more, roughly another 1 to 1.2 second win. In this profile the two options are close in raw impact, so the tie-breaker becomes speed and risk to build in four weeks. API aggregation usually touches fewer moving parts and can ship incrementally, one endpoint at a time, with fast, measurable wins, while a full code-splitting pass across a codebase, deciding what is route-critical versus deferred, tends to take longer to get right.

What would change the answer

If the trace showed one side clearly dominating, say 3 of the 4.5 seconds coming from the sequential API calls, I would start there since it has the higher ceiling. If most users are on a fast connection but a smaller, high-value segment is on mobile or slow networks where the JavaScript payload dominates their experience, that shifts the priority depending on who "fastest possible" is really meant to serve. And if the backend calls are shared with other teams' services, aggregating them carries wider blast radius and may take longer to get sign-off on than a frontend-only change, which pushes the four-week bet toward frontend first.

At least four distinct reasons a filter that "should" match can return zero rows: a type/format mismatch (customer_id stored as text with leading zeros or whitespace, compared to a bare integer), a NULL-related predicate elsewhere in the query silently dropping rows, an implicit filter from a JOIN turning into an INNER join, or simply querying the wrong schema, table, or environment (a replica lagging behind, or a staging database that looks identical to production).

Structured elaboration

A systematic debugging checklist, roughly in order of how cheap each check is:

1. Confirm you're querying the right place. SELECT current_database(), check the connection's schema search path, and confirm you're not accidentally pointed at a read replica that hasn't caught up yet.
2. Isolate the WHERE clause. Run SELECT * FROM orders WHERE customer_id = 12345 with no other joins or filters. If that alone returns nothing, the problem is in the predicate or the data, not elsewhere in the query.
3. Check for a type/format mismatch. SELECT customer_id, typeof(customer_id) FROM orders LIMIT 5 (or the engine's equivalent) to confirm the column isn't storing '12345 ' (trailing space) or '012345' as text, which won't equality-match a bare integer literal.
4. Check if a JOIN elsewhere in the real query silently filtered the row out. A LEFT JOIN followed by a WHERE clause on the joined table's columns behaves like an INNER JOIN (a separate, common trap).
5. Confirm the row genuinely exists in this exact table, not a similarly-named one, and that no row-level security policy or view definition is filtering it out invisibly.

Worked example

Given orders(customer_id TEXT) with a single row '12345 ' (trailing space): WHERE customer_id = '12345' returns zero rows, while WHERE TRIM(customer_id) = '12345' correctly finds it, confirming a whitespace mismatch as one concrete instance of reason #3.

Trade-offs and pitfalls

The instinct to immediately rewrite the query is usually premature; the fastest path is isolating variables one at a time (drop joins, drop extra filters, check raw data) rather than guessing. This checklist format is itself a useful thing to state out loud in an interview: it signals systematic debugging instinct rather than one lucky guess.

Direct answer

Reactive autoscaling scales based on what's happening right now (a metric crosses a threshold); predictive autoscaling scales based on a forecast of what's about to happen. Neither is inherently better; they answer different questions, and the metric you feed either one matters more than which mode you pick. The strongest signals are the ones closest to actual user-facing backlog or experience (request latency, queue depth) rather than machine-level resource stats (CPU, memory), which correlate with load but can lag or miss it entirely for I/O-bound services.

Structured elaboration

Reactive vs. predictive, and why the metric choice compounds. A reactive policy watching CPU will always be a step behind, because CPU rises only after load has already increased. A reactive policy watching queue depth is closer to real time, because a growing backlog is itself the leading indicator of "we're falling behind," not a downstream symptom of it. Predictive scaling (using historical traffic patterns or short-term forecasting to act before load arrives) reduces this lag structurally, but it only works well when it's built on a metric with a real predictable pattern (daily/weekly seasonality in request rate, for instance); it doesn't fix the fact that CPU is a noisy, lagging signal to forecast against in the first place.

Target-tracking math. A common reactive scaling pattern (used by cloud provider target-tracking policies and by Kubernetes' Horizontal Pod Autoscaler alike) scales replica count proportionally to how far the current metric is from target:

If 10 replicas are running at 80% average CPU against a 50% target:

The policy adds 6 replicas in this step. This same formula works for any metric with a sensible linear relationship to load (request rate, queue depth per worker), which is why the choice of which metric feeds it matters more than the formula itself: feed it a noisy or lagging metric and it will confidently compute the wrong target.

Worked example

A web-facing auto scaling group (ASG) targets 50% CPU with a 60-second scale-out cooldown and a 300-second scale-in cooldown, intentionally asymmetric: react to a spike quickly, but wait much longer before removing capacity. Without that asymmetry, consider what happens if CPU oscillates naturally between 45% and 65% around a single 50% threshold with equal cooldowns on both directions: the group scales out when CPU ticks above 50%, the added capacity immediately drags average CPU back below 50%, the group scales back in, CPU climbs again, and the fleet thrashes (adds and removes instances repeatedly) without ever settling. The fix has two parts: a hysteresis band (scale out above, say, 70%; scale in below, say, 30%, rather than a single shared threshold) so normal noise doesn't cross both boundaries, and a longer scale-in cooldown than scale-out cooldown, so the group is quick to protect against real load but slow and conservative about giving capacity back. That second part is the "safe scale-down" half of the policy: it's just as important as reacting fast to a spike, because a policy that scales in as aggressively as it scales out will flap on exactly the kind of noise a real production CPU curve always has.

Trade-offs & pitfalls

• Relying on a single metric is brittle: a service can be CPU-healthy while its queue backs up (I/O-bound work) or CPU-saturated while user latency is fine (CPU-bound but well within budget); combining two or three signals catches what any one alone would miss.
• Custom metrics add real value but add a real dependency: if the metric pipeline itself lags or goes stale, the autoscaler is making decisions on old data and can either overreact to a stale spike or fail to react to a live one.
• Symmetric cooldowns (same wait time for scale-out and scale-in) are a common oscillation trap; scale-in should almost always be more conservative than scale-out.
• Predictive scaling built on a metric with no real seasonal pattern (or one whose pattern just changed, e.g., after a product launch) will confidently mis-forecast; it needs the reactive layer as a backstop, not as a replacement.

Overview
Design an undo/redo that treats each user action as a Command with a reversible payload and minimal diffs; capture both application state changes and DOM mutations, batch related events, and replay by applying inverse/redo operations deterministically.

Data model

• Command { id, type, timestamp, payload, inverse, meta } — payload = minimal diff (e.g., text-range edit, attribute change, selection)
• Snapshot: occasional full serialized state (app state + DOM innerHTML) for fast recovery and boundary for compaction
• Diff store: compressed list of small ops (insert/delete/attr/selection) between snapshots

Example command shape:

const cmd = {
  id: "c1",
  type: "edit",
  payload: { path: ["body","p[2]"], offset: 5, delete: 3, insert: "foo" },
  inverse: { path: ["body","p[2]"], offset: 5, delete: 3, insert: "bar" },
  meta: { user: "local", coalesced: true }
};

Capturing user actions

• Use event handlers and MutationObserver:
  • High-level APIs (keyboard shortcuts, toolbar actions) emit explicit Commands (preferred).
  • For direct DOM edits, use MutationObserver to record structural/attribute/text diffs and map them to logical ops.
  • Track selection/cursor via selectionchange.
• Translate low-level mutations into semantic ops (e.g., “applyFormatting”, “insertText”) so replay is stable across environment differences.

Selective recording & batching

• Coalescing: merge adjacent text edits within a time window and same cursor context (debounce 300–1000ms) into one Command.
• Ignore noise: skip transient mutations (e.g., caret-only DOM tweaks) via filters.
• Size limits: keep a ring buffer with N commands and create snapshots when buffer exceeds threshold.
• Background compaction: periodically compress series of ops into a single diff or snapshot.

Replay / restore

• To undo: apply command.inverse (or compute inverse by reversing diffs) and restore selection from meta.
• To redo: apply command.payload.
• Efficient application:
  • Apply application-state diffs first (e.g., document model, annotations), then DOM patch operations.
  • Use patching (minimal DOM updates) rather than full innerHTML to preserve node identity where possible.
  • If mismatch detected or many ops, fall back to nearest snapshot plus replay subsequent diffs.
• Concurrency: for collaborative editing, integrate OT/CRDT layer so local undo replays transform-aware ops.

Trade-offs

• Fine-grained diffs = more memory but precise; snapshots reduce replay cost but cost storage.
• Prefer semantic commands for maintainability; fall back to mutation-to-command translation only where necessary.

This approach yields reversible, memory-bounded undo/redo that keeps both app state and DOM consistent and performant for a rich-text editor.