📊 Product Management

Differentiating an MVP from a throwaway prototype

Tests your grasp of strategic technical investment. Differentiate by intent: an MVP is the first version, a prototype is disposable. A great answer introduces Minimum Viable Architecture (MVA) to support future needs.

How would you A/B test a redesigned dashboard?

This tests your ability to translate a product goal into a technical plan. A good answer defines "engagement" with metrics, outlines the bucketing and instrumentation strategy, and discusses statistical significance.

What is an engineer's role in story refinement?

Tests your role in translating needs to tech specs. A great answer covers clarifying questions, task breakdown, sizing, and acceptance criteria. A red flag is passively waiting for tasks instead of proactively de-risking the work.

What information do you need in a user story?

This tests your ability to connect engineering work to user value. A great answer covers the user persona (who), their motivation (why), and measurable success criteria (what), explaining how this context informs technical decisions.

Shared Solution vs. Duplication for Cross-Cutting Concerns

Tests your judgment on trade-offs between duplication, coupling, and velocity. A good answer weighs the cost of premature abstraction against future refactoring, using triggers like the 'Rule of Three' and evaluating the concern's volatility.

How would you refactor an inverted test pyramid?

This tests your ability to create a pragmatic, multi-sprint strategy for tech debt. A good answer includes analyzing the suite, quarantining flaky tests, enforcing new coverage standards, and incrementally refactoring. A red flag is proposing a total rewrite.

Trunk-Based Development vs. GitFlow for High-Frequency Releases

This tests your grasp of modern CI/CD trade-offs. A great answer explains how TBD's frequent merges to main, decoupled from release by feature flags, enable velocity. Then, contrast this with GitFlow's complexity.

The Strangler Fig Pattern for Legacy System Refactoring

Tests your understanding of gradual legacy modernization and risk management. A great answer defines the pattern (new system grows over old), outlines the process (identify seams, build new, redirect traffic), and contrasts it with risky "big bang" rewrites.

How would you introduce TDD to a team?

This tests your ability to influence a team and implement change pragmatically. A great answer outlines a gradual adoption: understand context, advocate with data, pilot on a new feature, then scale. A red flag is demanding a sudden, mandatory switch.

Describe the stages of a CI/CD pipeline for a containerized app

This tests your practical knowledge of automated software delivery and risk management. A strong answer outlines CI, build, test, and deploy stages, including container-specific steps like image scanning and quality gates like automated testing and…

Balancing Emergent Design with Long-Term Architectural Vision

This tests your grasp of scaling Agile. A strong answer defines emergent design and intentional architecture, explaining how an 'Architectural Runway' provides the technical foundation to balance them. A red flag is treating this as an 'either/or' choice.

Explain the Test Pyramid and its strategic use

Tests your grasp of balanced testing trade-offs. A good answer defines the Unit, Service, and UI layers, explains the cost/speed rationale, and applies it to a feature strategy. A red flag is describing the pyramid but not its strategic 'why'.

Describe the TDD Red-Green-Refactor cycle

This tests your grasp of TDD's core loop and its design implications. A good answer defines Red (failing test), Green (minimal code to pass), and Refactor (improve structure).

How to Handle Poor Quality with Happy Stakeholders?

This tests your commitment to Scrum's Transparency pillar. A great answer involves being honest about unsustainable quality in the Sprint Review, proposing a plan (e.g., 20% capacity for tech debt), then using the Retrospective to fix the root cause.

Shift a Sprint Review from a Demo to a Working Session

Tests your understanding of Sprint Review's purpose: inspection and adaptation. A great answer shows how an engineer can partner with the PO to frame the session around goals, solicit feedback on the Increment, and collaboratively update the Product Backlog.

How do you ensure retro ideas become action?

This tests your ability to drive change by treating process improvements as formal work. A great answer suggests adding the top retro item to the next Sprint Backlog, making it visible, accountable, and part of the team's commitment.

Handling Negative Feedback in a Sprint Review

This tests your grasp of the Sprint Review's purpose (inspection, not acceptance). A strong answer has the Product Owner lead a discussion on the feedback, which then informs new, prioritized Product Backlog Items, rather than blaming or committing to…

What is the output of a Sprint Retrospective, and what happens next?

This tests if you create actionable outcomes, not just vent. The output is a plan to improve quality and effectiveness, with the most impactful items added to the next Sprint Backlog. A red flag is calling the output just 'notes' with no plan for integration.