Customer and User Obsession Questions
Reasoning from the customer or end user inward when making decisions in any role: building empathy for users, including buyers who are not the people who use the product; identifying and prioritizing customer pain points and workarounds; collecting and acting on customer feedback, including how representative it is, how it compares with usage data or satisfaction scores, and how it reaches the people who can act; bringing the voice of the customer into roadmap and technical trade-offs; advocating for users against internal or deadline pressure; and balancing customer needs against business goals and engineering constraints, such as a large account's bespoke request, power users versus everyday users, or retiring a feature. Includes stories of changing course because of customers or recovering after letting one down. Assesses whether a candidate starts from the customer's problem rather than from features or technology. Study design and fieldwork, research synthesis, personas and journey maps, analytics and experimentation mechanics, reliability engineering, customer-success operations, market and competitive research methods, and live handling of angry customers are covered elsewhere.
Was there a time you felt real passion for a product's users rather than for the technology itself? How did that change your engineering decisions, prioritization and trade-offs?
Sample Answer
Direct answer
Yes. I pick a story where I moved from caring about the elegance of the solution to caring about what the person using it was trying to do, and I show three concrete changes: what I built, what I prioritized, and what I traded away. I tell it in STAR order (Situation and Task, Action, Result), the standard structure for behavioral interview stories.
Situation and Task
I was the engineer on an ordering app used by small cafe owners at the counter during rush hour. I took pride in a clever offline sync design (the app keeps taking orders without internet and merges them with the server when the connection returns). Then I spent a shift watching an owner use the app and saw that what she dreaded was a lost order when the connection dropped, not anything about how sync worked.
Action
- Engineering decisions: I replaced my clever conflict-resolution design (the rules for what happens when two edits to the same order collide) with a simpler one that always kept both versions of an order and flagged the clash in plain words for a human to resolve in seconds. Example: the counter phone edits an order to 2 lattes while offline, a helper's tablet edits the same order to 3 lattes while offline. The clever design silently kept one and lost the other. The simple one shows "Order 41: 2 lattes or 3 lattes? Tap the right one." It was less elegant and much easier to trust.
- Prioritization: I moved a planned refactor (restructuring code without changing what it does) behind a fix that made a half-saved order visible on screen, because that failure cost the owner money in real time.
- Trade-offs: I accepted slightly clunkier code and a delayed internal cleanup to protect the owner's rush hour, and I said so openly to the team.
Result
Support complaints about lost orders dropped from about a dozen a month to two or three (illustrative; use your own measured figures), and the owners I had watched started using offline mode with confidence. I also began asking "who is on the other end of this change?" in design reviews.
Pitfall
Avoid vague "I love our users" language. The proof is a decision you made differently, and a cost you knowingly paid.
You rarely talk to customers directly in your role. How does customer obsession show up in your day-to-day decisions, and what would a skeptical colleague actually see you doing differently?
Sample Answer
Direct answer
When you never meet customers, obsession becomes a habit of asking "who is affected, and how will they experience this?" before choosing, and of using the closest available evidence about them: support tickets, error logs, product telemetry (usage data the product records automatically), and the people who do talk to customers. The test is behaviour, not belief. A skeptical colleague should be able to point at specific choices you made differently.
What a skeptical colleague would actually see
- A user-impact line in your design notes and reviews. Who is affected, what do they see when it fails, what do they do next? A real line looks like: "Impact: about 2% of checkouts (card payments over $500) hit this path; the user sees a spinner for 30 seconds, then a generic error, and may retry and be charged twice."
- Error and failure behaviour written for the person hit by it. The message says what happened, whether their data or money is safe, and what to do next.
- Metrics tied to a customer outcome. You alert on "checkouts failing" or "reports arriving late to users", not only on server load.
- Instrumentation chosen to answer customer questions. Instrumentation means the logging and metrics you add to code so you can see what it did. You log enough (with an identifier support can look up) that a ticket can be resolved without asking the customer to reproduce it.
- Regular proxy contact. A proxy is a stand-in source: someone or something that sees customers so you do not have to. You read a sample of recent tickets, sit in on a support or sales call now and then, and ask the people who do speak to customers what surprised them.
Worked example (a backend engineer)
A payment call times out. The default behaviour returns "Error 500". The obsessed version does three things differently:
- The message tells the user whether they were charged and that retrying is safe or not.
- The log line carries the order identifier, so support can answer "was I charged?" in one lookup.
- The alert fires on the failed-checkout rate rather than on CPU, so the team learns about customer pain first.
Nothing here needed a customer conversation. It needed the habit of imagining the person on the other end and checking tickets to confirm.
The same habit in other seats
- Network engineer, during an incident: decide the order of fixes by which customers are cut off (for example the region carrying the most checkouts), and write the status update in terms of what customers cannot do.
- Mobile developer: treat battery drain and crashes as customer-facing features, and check crash rate on older phones, not just your own.
- Machine learning engineer: read a sample of real model outputs and complaints, not only the offline accuracy score.
- Data engineer: choose schemas and keys so support can trace one customer's records, and keep the fields analysts need to answer "who was affected".
- Data analyst: build the dashboard for the business intelligence (BI) reader who will use it, with the customer-outcome metric first and plain labels.
Trade-offs and pitfalls
- Proxies mislead. Tickets over-represent people who bother to write in, and telemetry shows what users did, not why. Arrange some direct exposure even if it is only one call a quarter.
- Do not claim to speak for customers from inside your head; cite the ticket, the log or the person who talked to them.
- If your work never changes because of customer evidence, you are doing the same job as before with a nicer label.
Describe how you simplified a complex feature to deliver core customer value sooner. Walk me through the original scope, what you cut, how you validated the minimal version with customers, and what happened.
Sample Answer
Direct answer
I tell it in STAR order (Situation and Task, then Action, then Result, the standard structure for behavioral interview stories), covering the original scope, the cut, the customer test and the outcome, and I make clear that the cut was driven by a customer job (the task the customer is trying to get done), not by what was easiest to build. Sample story below; the shape is what matters.
Situation and original scope (Situation, Task)
Our customers needed to see how their team was performing. The first plan was a reporting module with five parts: a drag-and-drop dashboard builder, twelve chart types, scheduled email delivery (reports emailed automatically on a timetable), CSV and PDF export, and role-based sharing (an admin chooses who in the company can see which report). Estimated work was several months, and we had no real evidence that customers needed all five.
What I cut and why (Action)
- Cut: the dashboard builder, ten of the twelve chart types, scheduled email delivery, PDF export and role-based sharing.
- Kept: two fixed charts answering the question customers raised most often ("is my team getting faster or slower?") plus CSV export.
- Rule used: keep what a customer cannot complete the job without, and cut what only makes the job nicer.
- Applying the rule: the job was "tell whether my team is speeding up or slowing down." Two fixed charts plus CSV export complete it, and the CSV covers anyone who wants a custom view in a spreadsheet. The builder, extra chart types, scheduled email, PDF and sharing make the job nicer, but customers could already finish it without them.
How I validated the minimal version
I showed a clickable mock (a prototype of screens that respond to clicks but has no real working code behind it) to a handful of customers, asked each to do the job with their own numbers, and watched where they hesitated. Then we shipped to a small group and checked whether they came back the next week and exported data, rather than asking whether they liked it. The honest limit: a handful of interviews shows what confuses people, not how many want it.
What happened (Result)
It shipped in about six weeks against an original estimate of about five months (illustrative figures; use your real ones). Customers used the two charts and the export; some asked for scheduled email (the one cut item that proved wanted), so that went next, while nobody asked for the builder and we never built it. What I would do differently: I would have asked the first customers about scheduling before the mock, because two of them raised it unprompted.
Pitfalls
Do not tell a story where cutting was only about speed. Show the customer evidence for what stayed and what went, and name something you got wrong.
Give an example of a technical improvement you made and how you showed that it changed something customers actually experienced.
Sample Answer
Direct answer
Pick an improvement where you can draw a line from your technical change to something a customer felt: faster pages, fewer failed payments, fewer crashes. Show the before-and-after measurement from the customer's side, not just internal numbers like CPU usage, and be honest about other factors.
Structure
- Problem as customers experienced it. A complaint, a ticket tag or an abandonment point.
- Change. One or two sentences, in plain terms.
- Proof it reached the customer. Use a customer-side measure and a fair comparison:
- A real-user measurement (timing taken from actual customer sessions, for example a small script that reads the browser's built-in performance timing when the checkout form becomes usable and sends it, with the device type, to analytics) rather than only a test machine.
- A staged rollout (release to a small share of users first) so the old and new versions can be compared in the same week. The 10% who get the new code are the rollout group; the other 90% keep the old code and act as the control group, the comparison group that lives through the same weeks and events but does not get your change.
- A customer signal such as tickets, abandonment or retries.
- Caveats. What else changed in that period.
Worked example (illustrative numbers)
A frontend developer notices checkout feels slow on mid-range phones. They defer loading a large recommendations script until after the payment form appears. Rollout goes to 10% of users first. The metric is the 95th percentile (p95) page-ready time: the time within which 95 out of 100 visits finish, so it shows the slow tail that customers complain about, not the average.
In the 10% phase, p95 page-ready time was 3.9 s for the rollout group against 5.7 s for the control group in the same two weeks (illustrative), which is 1.8 s or about 32% faster. Customer-side signal: support tickets tagged "slow checkout" per 1,000 active users. Suppose that was 18 per 1,000 before and 11 per 1,000 after, comparing four-week windows. That is 7 fewer per 1,000, about a 39% reduction (7 divided by 18). The honest line to add: "a marketing campaign ended in the same window, so I also compared the 10% rollout group against the control group in the same weeks, and the gap held." The control comparison is the p95 gap above: the campaign reached both groups, so it cannot by itself explain a gap between them. This holds only if users were assigned to the rollout group at random (for example by a hash of the user ID), so say that in the story. Even then it supports 'contributed to', not 'proved': the ticket drop (18 to 11 per 1,000) is a before and after comparison that the campaign ending can still distort, so also report tickets per 1,000 for the rollout group against the control group over the same weeks.
Pitfalls
- Internal metric as proof. "Server time dropped" does not show a customer noticed.
- Averages hide the tail. Report the tail or the share of affected customers.
- No comparison group. Before-and-after alone cannot separate your change from the calendar.
- Overclaiming. Say "contributed to" unless you had a clean control.
A bug affects only 2% of customers, but they are your highest-value ones, and the team is midway through a new feature. How do you decide, and how do you explain the call to product and sales?
Sample Answer
Direct answer
Decide on severity and cost of delay (what each extra week of waiting costs), not on the 2% figure. If those customers carry a large share of revenue and the bug blocks work or loses data, waiting gets more expensive each day. I would interrupt the feature with the smallest team that can fix the bug, protect the feature date as far as possible, and tell product and sales what we are doing, why, and when.
Step 1: size it in business terms
Illustrative: 500 customers in total, with $30M of annual recurring revenue (ARR, the yearly subscription revenue) across all of them, so the average customer pays $60k. The 2% affected are the biggest accounts, averaging $200k each.
2% of 500 customers = 10 customers
10 x $200k = $2.0M affected
$2.0M / $30M total ARR = 6.7% of revenue
$30M - $2.0M = $28M across the other 490 customers = about $57k each
The affected revenue share (about 7%) is a more honest headline than "2% of customers": each affected account pays more than three times the average ($200k vs $60k).
Cost of delay, with illustrative numbers. Suppose the bug blocks their work and each of the 10 accounts has a 5% chance per month of leaving. Expected loss is 10 x 0.05 x $200k = $100k of ARR put at risk for each month the bug stays open (a yearly revenue figure, lost for good if a customer leaves). A feature expected to add $240k of ARR a year earns about $20k a month, so a one-month slip costs about $20k of revenue, delayed once. The units differ, which favours the bug even more: each month of delay risks $100k of yearly revenue permanently, against $20k of revenue pushed back once. Waiting on the bug costs more than slipping the feature, and if a small team can fix the bug in less than a month (an assumption to confirm with engineering), the feature slips by less than that.
Step 2: severity, trend, workaround, fix size
Is it data loss, blocked work or an annoyance? Is it growing as more accounts adopt the affected setup? Is there a workaround? Is there a contractual commitment (a promise written into the customer's contract, such as an uptime or data-safety guarantee)? How big is the fix?
Step 3: apply an interrupt rule you would have agreed before the argument
An interrupt rule is a pre-agreed statement of which kinds of bug stop planned work.
| Bug | Fix size | Decision |
|---|---|---|
| Blocks work or loses data, no workaround | Any | Interrupt now with a small team |
| Slows work, workaround exists | Small | Fit in this sprint (the team's current fixed work period, often two weeks) beside the feature |
| Slows work, workaround exists | Large | Schedule right after the feature, with a date and customer communication |
| Cosmetic | Any | Backlog |
The table also needs to say what happens to combinations it does not list. A bug that blocks work but has a workaround is handled by fix size like the two 'slows work' rows, except that data loss interrupts regardless of any workaround. A bug that slows work with no workaround moves up to the interrupt row when the affected accounts are high-value or the slowdown is growing.
Step 4: protect the feature
Pull one or two engineers, not everyone. Re-estimate the feature date and state the new one. Cut feature scope before quality.
Explaining the call
- To product: affected revenue share, severity, trend, the cost of delay against the days the feature slips, and what we will not do.
- To sales: the account list, what to say to customers (acknowledged, workaround, fix date, named contact), and a request to flag contractual commitments. Do not promise a date beyond the estimate.
Variation: a minority on older devices versus a marketing banner
A minority of users on older phones suffer crashes or slowness, while marketing wants a heavy banner everywhere. Check the share of users on those devices (illustrative: 8% of 50,000 monthly active users is 4,000 people), whether they are active and valuable, and whether the banner is optional and reversible. A feature flag (a switch that turns code on for chosen users) can ship the banner to capable devices and a lightweight static version to older ones while the crash is fixed on schedule. A banner is optional and reversible; a crash is harm.
Pitfalls
- Letting the percentage frame the discussion.
- A silent slip of the feature date, which erodes trust faster than an announced one.
- What would flip my call: if the affected revenue is tiny and an easy workaround exists, the bug waits behind the feature with a firm date.
Unlock Full Question Bank
Get access to all 6 Customer and User Obsession interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.