DoorDash Software Engineer (Junior Level) Interview Preparation Guide

Direct answer. JSON Merge Patch (RFC 7396) treats the patch as "the object should end up looking like this," where any field present with a value REPLACES it, any field present with a null REMOVES it, and any field absent is left untouched; it cannot express "remove this array element" or "insert at this position" without replacing the whole array. JSON Patch (RFC 6902) is a list of explicit, ordered operations (add, remove, replace, move, test) against exact paths, so it CAN express precise structural edits, at the cost of a more verbose, less human-writable request body.

Setting null vs. removing entirely. For a preferences object {"newsletter": true, "theme": "dark"}:

• Merge Patch to remove theme entirely: {"preferences": {"theme": null}}; a null value in a Merge Patch means "delete this key," not "set it to the JSON value null," which is a common point of confusion since the resource cannot actually end up storing a literal null for that field using this format.
• JSON Patch to remove theme entirely: [{"op": "remove", "path": "/preferences/theme"}], which is unambiguous, since JSON Patch has a genuinely distinct "remove" operation, unlike Merge Patch's overloaded use of null.
• To set theme to a literal null VALUE (as opposed to removing the key) is something Merge Patch cannot express at all; JSON Patch can: [{"op": "replace", "path": "/preferences/theme", "value": null}].

Server-side validation for each. For Merge Patch, validate the resulting MERGED object after applying the patch, since the patch itself is just partial data, not a set of operations to sanity-check individually. For JSON Patch, validate each OPERATION (does the path exist for a remove/replace? is the value the right type for an add?) as well as the final result, since an individual operation can be invalid even if you never get to check the end state (for instance, "replace" against a path that does not exist should fail, not silently succeed as an add).

Combining with a concurrency check. Either format pairs the same way with an If-Match header: read the resource's current ETag, send it as If-Match alongside the patch body, and the server rejects with 412 Precondition Failed if the ETag no longer matches, meaning something else changed the resource since the client last read it. This is true regardless of WHICH patch format you used to construct the update; the concurrency check operates on the resource's version, not on the patch's contents.

Trade-offs and pitfalls. The most common mistake with Merge Patch is assuming you can null out a NESTED array element the way you null out an object field; Merge Patch's null-means-delete rule only applies to OBJECT KEYS, and merging into an array replaces the whole array wholesale, which surprises engineers who expect Merge Patch's per-field semantics to extend uniformly to array contents.

Meeting structure

• 5m: Welcome, blameless rules, objectives (learn, prevent, assign)
• 10m: Impact summary (who/what/when/how many customers, revenue/SLAs)
• 20m: Timeline walkthrough (reconstruct minute-by-minute using logs/alerts/commits)
• 20m: Evidence review (deploy artifact, CI logs, monitoring, config changes)
• 25m: Root-cause analysis (facilitated 5 Whys + fishbone / causal-factor tree)
• 15m: Identify contributing factors and compensating controls missing
• 15m: Action item creation (owner, priority, target date, verification criteria)
• 10m: Close: communicate next steps and follow-up cadence

Postmortem artifact (deliverable)

• Single living doc (wiki or repo) with:
  • Executive summary (impact & timeline)
  • Detailed timeline with log/snippet links
  • Root cause statement (concise)
  • Contributing factors (technical, process, human, tooling)
  • Action items (owner, priority, due date, verification method)
  • Rollback/playbook + links to alerts/dashboards
  • Lessons learned and communication plan
  • Postmortem review notes and closure sign-off

How I’ll identify root cause and contributing factors

• Reconstruct timeline from monitoring/alert logs, deployment metadata, git commits, and CI artifacts.
• Reproduce failure path in a sandbox if safe.
• Interview involved engineers with blameless, fact-focused questions.
• Apply 5 Whys to get to immediate cause and fishbone to categorize systemic contributors (tests, deployment process, observability, permissions).
• Validate by correlating artifacts (e.g., commit introduced change X → CI missed test Y → canary not run → full rollout).

Three concrete remedial steps

1. Canary + automated rollback: Require staged canary rollout with automated health checks; if canary fails, pipeline rolls back and blocks promotion.
2. Strengthen pre-deploy gates: Add targeted integration/smoke tests to CI, enforce mandatory staging smoke and manual approval when risk > threshold; add static analysis or contract tests for risky subsystems.
3. Runbooks + drills + alert tuning: Build a one-page runbook for this failure class, train on-call via tabletop drill, and adjust alert thresholds/ownership to reduce detection time.

Measuring effectiveness over next quarter

• Track MTTR (goal: reduce by 50% vs incident), mean time to detection, and change-failure rate for deployments (target: < X% depending on baseline).
• Measure % of deployments using canary/feature-flag (target: 100% for high-risk services).
• Count number of incidents caused by deployments (target: zero or downward trend) and completion rate of action items (100% closed or migrated to backlog with justification).
• Monitor runbook usage and drill frequency; survey on-call confidence pre/post drills.
• Review metrics weekly for 4 weeks, then biweekly; close the postmortem when actions verified and KPIs show sustained improvement.

Direct answer
A repeatable way to shape a real story into a principle-mapped interview answer: start from the story, not the principle; identify which one or two principles it most naturally demonstrates; structure the telling so the actions carry the evidence rather than announcing the principle by name; close with a concrete, ideally measurable result; and only state the principle's name explicitly if the interview format specifically calls for it.

Structured elaboration

1. Inventory first. Write down six to ten real situations spanning different flavors of experience (a technical trade-off, a disagreement, a mistake, a moment of leading without formal authority, a customer-facing choice).
2. Map second. For each story, ask what your actions actually demonstrated, rather than starting from which principle you want to show. Mapping from story to principle, not the reverse, keeps the story honest.
3. Structure with situation, task, action, result, and put roughly 60 to 70 percent of the telling time in the action section, since that is where the principle actually shows up.
4. Quantify the result where you honestly can. Where you can't, describe a concrete, verifiable change instead of a vague feeling of success.
5. Name the principle explicitly only if the format calls for it. Some interviewers want you to state it directly, in which case one closing sentence is enough; narrating the principle's name throughout reads as reciting rather than demonstrating.

Worked example
Consider a story about restoring a degraded service faster than the standard escalation path would have. Situation: a service degraded during a high-traffic period. Task: the candidate was the person on point. Action: rather than escalating immediately and waiting, they spent the first several minutes gathering the most likely signals, formed a hypothesis, tested it with a small, reversible change, and escalated only once they had evidence rather than a guess. Result: the issue was resolved well inside the window that would have triggered a customer-facing incident, and the candidate wrote up the diagnostic path afterward so the next person facing the same symptom could skip the initial investigation. If the interviewer's principle is framed around ownership or thorough investigation, it is the methodical hypothesis-testing and the follow-up write-up, not a sentence claiming the principle, that demonstrate it.

Trade-offs and pitfalls
Repeating the principle's name throughout a story ("this shows my ownership, which is also ownership because...") reads as reciting rather than demonstrating; state it once, if at all. Choosing a story because it sounds impressive rather than because it honestly demonstrates the specific actions a principle cares about is a common mismatch that a practiced interviewer will probe past. Time-boxing also matters: a detailed answer that never reaches a result is a frequent failure mode, so keep the action section rich but always land on a result.

Requirements & constraints (clarify): read-heavy catalog at 10k QPS, complex filters: category, price range, free-text, low-latency (<100–200ms), near-real-time updates, moderate write volume, consistency trade-offs acceptable for reads.

Compare options (primary reasons to pick):

1. Document store (MongoDB)

• Why: flexible schema for product attributes, native JSON queries for filters, built-in secondary indexes (compound, text), easy horizontal scaling via sharding.
• Strengths: simple developer model, good for varied product shapes, strong single-document atomicity.
• Drawbacks: full-text search is limited vs. search engines (relevance, fuzzy, scoring), range queries and aggregations are OK but can be heavier at 10k QPS without careful indexing and replicas.

2. Search engine (Elasticsearch)

• Why: optimized for free-text, relevance scoring, facets/aggregations, very fast inverted-index queries for high QPS.
• Strengths: excellent full-text, scalable read performance, rich filtering + sorting, built-in aggregations for faceted search.
• Drawbacks: eventual consistency (near-real-time indexing), more complex ops, larger storage footprint, not ideal as a source-of-truth (complex updates/transactions).

3. Relational DB with proper indexes (Postgres)

• Why: strong consistency, complex relational queries, efficient range queries with B-tree, GIN/GIST for full-text, materialized views.
• Strengths: ACID, predictable behavior, cost-effective for structured schemas, powerful indexing options.
• Drawbacks: full-text and large-scale faceted search can be less performant than ES at 10k QPS; scaling writes/reads requires replicas and partitioning.

Trade-offs summary:

• If primary need = relevance-based free-text at scale → favor Elasticsearch as query engine.
• If schema variability and developer speed matter, MongoDB fits as primary store.
• If strict consistency and relational integrity matter → Postgres.

Polyglot (recommended hybrid) architecture:

• Source-of-truth primary DB: Postgres or MongoDB (choose based on schema needs & transactional requirements).
• Search index: Elasticsearch for query-serving (free-text, facets, sorting).
• Sync pipeline: use Change Data Capture (Debezium/Kafka) or application-level update events to stream writes from primary DB to ES; ensure idempotent upserts and handle delete tombstones.
• Read layer: API service queries ES for search requests (fast, relevance-aware). For operations needing authoritative data (e.g., price verification at checkout), fetch from primary DB or use cache.
• Caching & CDN: Redis or in-memory caches for hottest queries, and edge caching for static listing pages.
• Scalability & reliability: ES clusters sized for 10k QPS with sharding/replica factor; DB read replicas for analytics; monitoring, backpressure, and reindexing strategy for schema changes.
• Consistency handling: accept near-real-time search indexing (sync latency seconds); surface “last updated” timestamps; for strict correctness require a read-after-write from primary DB.

Operational notes:

• Benchmark common query patterns, tune indexes and shards, precompute faceted counts or use composite aggregations.
• Build health checks and reindex automation; design for idempotent sync and fallback to primary DB on ES outages.

This polyglot approach gives best UX for search performance while preserving data integrity and developer ergonomics.

Direct answer. A shape-mismatch error tells you two tensors disagreed in dimension somewhere in the forward pass, but the traceback often points at the operation that FAILED, not the operation that introduced the wrong shape several layers earlier, so the debugging process is really about walking the shape forward from the input until it diverges from what you expect.

Step-by-step approach.

1. Print the input shape first, and compare it against what the first layer actually expects. A surprising number of shape bugs are simply "the input isn't shaped the way I assumed," not a bug in the model at all.
2. Use a model summary tool (or manually print .shape after each layer in a quick forward pass) to see the shape at every stage in one pass, rather than binary-searching by commenting out layers one at a time.
3. Add explicit shape assertions inside custom layers, at the point where a specific shape is assumed (assert x.shape[-1] == self.expected_dim, f"got {x.shape}"). This turns a downstream, confusing shape error into an immediate, precisely-located one the next time the bug is triggered, which pays for itself the first time someone else hits a variant of the same bug.
4. Write a small unit test with a known, fixed input shape that exercises just the suspect layer or block in isolation, rather than the whole model, so you can iterate on the fix without paying the cost of a full forward pass through everything else.

A concrete example of why step 1 matters. A very common real case: a model expects batch-first input (batch, seq_len, features) but receives (seq_len, batch, features) from a data loader or a different framework's convention. The shapes are individually valid tensors, nothing crashes until several layers in when a dimension that "coincidentally" matched for a while finally doesn't, at which point the error message points at a layer far from the true cause (the data loader).

The unit test that prevents recurrence. Something as small as:

def test_encoder_output_shape():
    x = torch.randn(4, 10, 32)  # (batch=4, seq_len=10, features=32), the CONTRACT this layer expects
    out = encoder(x)
    assert out.shape == (4, 10, 64), f"expected (4, 10, 64), got {out.shape}"

run in CI on every change to the layer or anything upstream of it, catches this class of bug the moment a shape contract is violated, rather than three deploys later when someone finally notices predictions look wrong.

Direct answer
A compact, high-defect-detection date-parser suite is built by picking one representative input per distinct CALENDAR RULE the Gregorian calendar enforces, rather than one test per invalid string, since the rules (not the individual strings) are what the implementation can independently get wrong.

Structured elaboration and worked example (executed; the original draft's nested if/raise bodies were flattened to a single indent level and did not parse as Python at all, fixed below)

from datetime import date

def parse_date(s):
    parts = s.split('-')
    if len(parts) != 3:
        raise ValueError(f"invalid format: {s}")
    y, m, d = parts
    if not (len(y) == 4 and len(m) == 2 and len(d) == 2):
        raise ValueError(f"invalid component width: {s}")
    return date(int(y), int(m), int(d))

Valid partition (one representative per rule), all executed and matching:

• Ordinary date: 2026-01-01
• Leap year (divisible by 4): 2024-02-29
• Leap year EXCEPTION-of-the-exception (divisible by 400, IS a leap year despite being a century): 2000-02-29
• Year-end boundary: 2026-12-31

Invalid partition (one representative per rule), all executed and correctly rejected:

• 2023-02-29: NOT a leap year, Feb 29 invalid
• 1900-02-29: divisible by 100 but NOT by 400, so NOT a leap year despite being divisible by 4 (the century exception)
• 2026-02-30: February never has 30 days regardless of leap-year status
• 2026-13-01: month out of range
• 2026-00-15: month zero
• 2026-04-31: April has only 30 days
• 26-01-01: wrong year width (2-digit year)
• 2026/01/01: wrong separator (format-shape error)
• "": empty input

Why this is the compact/high-yield partition, not an arbitrary list
The leap-year rule alone has THREE distinct sub-cases a naive implementation can get wrong independently: 'divisible by 4 is a leap year' (2024), 'divisible by 100 is NOT a leap year' (1900, 2023's ordinary-year contrast case), and 'divisible by 400 IS a leap year, overriding the /100 exception' (2000). A suite testing only 2024 (leap) and 2023 (not leap) would pass against an implementation that forgot the /400 override entirely, since a naive year % 4 == 0 check happens to get 2024 and 2023 right while silently mishandling 1900 and 2000; the four leap-year-family cases are the minimum needed to distinguish a fully correct implementation from three distinct plausible-but-wrong ones.

Timezone and internationalization pitfalls
This parser deliberately operates on a naive (timezone-unaware) date-only string, which sidesteps timezone bugs entirely, but that is itself a design decision worth testing explicitly: if the SAME date string is later combined with a time component and a timezone elsewhere in the system, a test should confirm the date-only parser's output is never silently treated as "midnight UTC" or "midnight local time" without that assumption being documented, since combining a naive date with an implicit timezone assumption is a common source of off-by-one-day bugs across region boundaries. Internationalization pitfalls specific to this exact format (YYYY-MM-DD, ISO 8601) are comparatively low, since it is unambiguous about field order; the risk shifts to OTHER formats (MM/DD/YYYY vs DD/MM/YYYY) that this parser correctly rejects via the format-shape check.

Trade-offs & pitfalls
A suite optimized purely for compactness risks under-testing the format-shape failures (wrong separator, wrong component width) in favor of the more "interesting" calendar-rule cases; both categories are needed, because a format-shape bug (accepting 2026/01/01) and a calendar-rule bug (accepting 2026-02-30) are entirely independent code paths that can each be broken without affecting the other.

Direct answer

Find the shared goal underneath the surface disagreement, both sides usually want the launch to succeed, they disagree on what risk is acceptable to get there. Then convert the abstract tension into a concrete, time-boxed trade-off (what ships now versus what's deferred), with clear ownership of whatever risk gets accepted.

Framework

Reframe before negotiating. Name the actual shared objective (a successful launch) instead of letting the conversation stay framed as one function's priority against another's.

Make the trade-off concrete. Lay out a short options list showing what changes at each risk-versus-speed level, and the cost of each option. Where possible, propose a phased release, ship a reduced-risk version now, defer the rest, rather than forcing an all-or-nothing choice.

Assign ownership of the accepted risk. Whoever accepts a shortcut, for example skipping a test cycle or deferring hardening, should be named explicitly, so the decision isn't 'the team decided' with no accountability attached.

Other shapes this same tension takes. It doesn't always surface as engineering-stability-versus-speed. The identical negotiation shows up as design, performance, accessibility, and time-to-market trade-offs, for example a fully accessible, polished interaction versus a simpler version that ships on the marketing date, and as security, network, and product integration-deadline trade-offs, for example a security or network team wanting a longer hardening pass before a product integration ships, against a fixed launch date on the product side. The mechanism doesn't change across these framings: name the shared goal, make the trade-off explicit and time-boxed, and assign ownership of the risk that's accepted.

Worked example

Situation: engineering wanted an additional hardening and testing pass before a release; the business side had a customer commitment tied to a fixed date, eight weeks out.
Action: convened both sides and reframed the disagreement as 'how do we hit the date without an unacceptable stability risk', not engineering against the business. Broke the release into a smaller core scope that could pass full testing within the eight weeks, with the higher-risk pieces deferred to a fast-follow. Named engineering as the owner of the go/no-go call on stability for the core scope, and named the business side as the owner of communicating the phased scope to the customer.
Result: the reduced-risk core shipped on the committed date, and the deferred piece landed two weeks later with no incident. Because the trade-off was explicit and time-boxed rather than a vague 'we'll be a bit more careful', both sides could tell their own stakeholders exactly what was decided and why.

Trade-offs and pitfalls

• Treating this as a one-time negotiation, rather than designing a recurring mechanism such as a standing risk-versus-release framework, means the same fight repeats at every deadline.
• Splitting the difference without being explicit about what's actually being risked satisfies no one and hides the real trade-off from both sides.
• The senior version of this answer describes redesigning the choice so it isn't zero-sum, the phased release, not describing how you convinced the other side to give in.

Direct answer

Structure a technical explanation as a small number of steps that each answer one question the listener actually has, in the order they would naturally ask it: what is this, why does it matter, what are the pieces, how do they work together, show me one real case, then open it up. That ordering reduces how much a listener has to hold in their head at once, and it gives you a clear place to pause and reset if a question knocks you off track.

Structured elaboration

A six-step scaffold maps to how listeners actually process a new topic: overview, context, components, flow, example, then questions.

• Overview: one sentence stating what this is and why it's worth the next five minutes. Orients attention before any detail arrives.
• Context: the business driver or constraint that made this necessary. Information without a reason attached gets forgotten fast.
• Components: name the pieces and what each one is responsible for. Breaking a system into named chunks is what lets someone reason about three things instead of one overwhelming thing.
• Flow: how the pieces interact, in sequence or as a simple diagram. This is where most confusion actually lives, so it comes only after the listener has the vocabulary from Components to follow it.
• Example: one concrete, real case, ideally with a specific input and outcome. Abstract structure becomes retrievable once it's attached to something real.
• Questions: reserved deliberately for the end, so side-questions don't derail the sequence before the listener has enough context to ask a well-formed one.
  Why this order works cognitively: each step only introduces what the previous step already gave the listener a place to put. Naming the pieces before explaining how they interact means the listener isn't hearing an unfamiliar noun and a new relationship in the same sentence, which is what actually causes people to check out midway through a technical explanation.

Worked example

Explaining an event-driven order pipeline to a stakeholder group:
"This is how we process an order the moment it's placed, instead of checking for new orders every few minutes (overview). We built it because the old approach meant a customer's order confirmation could lag noticeably behind the order itself, which was showing up in support tickets (context). There are three pieces: the order service that records the order, a queue that holds it briefly, and a fulfillment service that picks it up (components)."
Someone interrupts: "Wait, what's a queue?" That's a clarification, not a deep-dive, so it gets a one-sentence answer on the spot: "Just a waiting line for messages, so the order service doesn't have to wait around for fulfillment to be ready." Then a bridge back: "So, picking back up at the queue," and the flow step continues from where it left off, rather than restarting.
If instead the question had been "how do you handle a failed fulfillment attempt," that's a deep-dive: acknowledge it, give a short answer or note it for the questions step at the end ("good one, let's come back to that once you've seen the whole flow"), and resume with a short recap sentence to re-anchor everyone before continuing.

Trade-offs and pitfalls

The scaffold breaks down if context gets skipped: a listener who never hears why something matters will tune out before components even starts, no matter how clean the rest of the structure is. Treating every interruption as worth a full deep-dive derails the sequence and loses the rest of the room; treating every interruption as a distraction to defer makes the audience feel unheard. The judgment call is a quick read of the question itself: is this person missing one word (answer now), or missing the shape of the whole thing (that's a sign to zoom back out to overview, not push forward into more detail).

Situation: I'm reviewing a PR that changes an exported API in a shared library used by teams with different release cadences.

Governance checks (pre-merge):

• Verify API change rationale and design doc link (motivation, alternatives, migration path).
• Ensure API is covered by tests (unit, integration, and consumer contract tests).
• Confirm code adheres to style/security/linting and static analysis passes.
• Check versioning bump follows semver policy and is recorded in changelog.
• Validate backward-compatibility matrix and that feature flags or opt-ins exist if needed.
• Confirm documentation updates (public docs, examples, deprecation notes).

Compatibility guarantees to enforce:

• Preserve existing behavior for current major version (no breaking changes in minor/patch).
• If breaking, require major-version bump and explicit migration guide with code examples.
• Enforce deprecation period (e.g., N releases / M months) with automated warnings in runtime/logs or compile-time where possible.
• Maintain binary compatibility for compiled languages and ABI notes where relevant.

Notifying downstream teams:

• Post to designated channel (e.g., #library-updates) with summary, impact, migration steps, and timelines.
• Open a consumer-impact issue listing known consumers and owners.
• Send targeted emails/Slack to owners of high-risk consumers.
• Publish release notes and changelog entries with examples and deprecation banner.

Release coordination before merge:

• Require consumer-driven contract tests pass (mock consumers or CI that runs representative consumers).
• If breaking, schedule a coordinated rollout window and require sign-off from downstream owners (explicit ACKs).
• Gate merge on successful canary/integration tests and a feature-flag rollout plan.
• Attach rollback plan and owner contacts to the PR.
• If cadence mismatch, coordinate version promotion strategy (publish canary/preview artifact, then stable after consumers adapt).

This approach minimizes surprise, enforces clear compatibility guarantees, and makes coordination explicit so consumers can upgrade safely.

We can treat this as a "binary search on the answer" (parametric search). For any candidate length L, compute how many pieces we get by summing ropes[i] / L; if >= k, L is feasible; otherwise not. Search L in [1, max_rope_length]. Handle preconditions (k>0), zero-length ropes, and insufficient total length.

#include <vector>
#include <algorithm>
using namespace std;

int maxLength(vector<int>& ropes, int k) {
    // Preconditions: k should be > 0. If not, return 0 as no meaningful pieces requested.
    if (k <= 0) return 0;
    if (ropes.empty()) return 0;
    
    int maxR = *max_element(ropes.begin(), ropes.end());
    if (maxR == 0) return 0; // all ropes zero-length
    
    long long total = 0;
    for (int r : ropes) total += r;
    if (total < k) return 0; // cannot produce k pieces of length 1
    
    int lo = 1, hi = maxR, ans = 0;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2; // candidate length
        long long pieces = 0;
        for (int r : ropes) pieces += r / mid; // integer division
        if (pieces >= k) {
            ans = mid;      // mid is feasible, try larger
            lo = mid + 1;
        } else {
            hi = mid - 1;   // mid too large, try smaller
        }
    }
    return ans;
}

Key points:

• Use integer division r / L to count pieces.
• Search domain excludes 0 to avoid division by zero.
• Use long long for piece accumulation to avoid overflow on large arrays.
  Time complexity: O(n log M) where n = ropes.size(), M = max rope length.
  Edge cases: k <= 0, empty vector, all ropes zero, total length < k (can't make k pieces of length 1), duplicates and large values handled.