sodcalculator

10 Tech How-To

Product Thinking in Software Engineering Workflow

Guide 10-46317 · Updated · Step by step

This guide shows you how to weave product thinking into your daily software engineering workflow, so you build features that solve real user problems, not just technically clever ones. You’ll learn practical steps to shift from “how” to “why,” prioritize effectively, and collaborate better with product managers and designers. No special tools are required—just a willingness to ask better questions and change how you approach your backlog.

What You’ll Need

  • A current project or backlog you’re working on (even a personal project works)
  • Access to your team’s product roadmap or feature list (if available)
  • A way to take notes (digital or paper)
  • Basic understanding of your users (or a way to reach them, like analytics or feedback channels)

Step-by-Step

  1. Start with the problem, not the solution. When you pick up a ticket or start a new feature, write down the user problem it solves in one sentence. If you can’t, ask your product manager. For example, instead of “build a CSV export button,” the problem might be “users need to analyze their data offline.” This reframing guides your technical choices.
  2. Define success metrics before writing code. For each feature, ask: “What would tell us this is working?” It could be a metric like “reduced time to complete a task” or “increased user retention.” Write this down and share it with your team. If you can’t define a metric, the feature might not be worth building yet.
  3. Map the user journey. Sketch the steps a user takes to accomplish the task your feature addresses. Include entry points (where they start), actions (what they do), and the final outcome. This helps you see where your feature fits and what might break the flow.
  4. Ask “why” five times. When you’re given a requirement, dig deeper. For example, “Why do we need a dark mode?” → “Because users work at night.” → “Why at night?” → “Because they’re in different time zones.” → “Why is that a problem?” → “Because our current contrast is too bright.” This leads to better solutions, like auto-adjusting brightness instead of a manual toggle.
  5. Prototype the smallest thing that tests the risk. Instead of building the full feature, identify the riskiest assumption (e.g., “users will want to share results”). Build a minimal version that tests that assumption—maybe a simple button that copies a link. This saves time and validates the idea early.
  6. Involve users early and often. Share your prototype or even just a description with a few users (or your product team if you don’t have direct access). Ask open-ended questions like “What would you do with this?” and “What’s missing?”. Don’t just confirm your own assumptions.
  7. Write user stories that include the “why.” When you create or refine tickets, include the user problem and success metric in the description. For example: “As a user, I want to export my data so I can analyze it offline. Success: 50% of users use the export within the first week.” This keeps the team aligned.
  8. Review your work against the problem. Before you finish, step back and ask: “Does this solve the user’s problem?” If you’ve added extra features or complexity that don’t serve that goal, consider cutting them. Simplicity is a product decision.
  9. Track outcomes, not just outputs. After release, check the success metric you defined. Did it move? If not, why? This feedback loop turns your engineering work into a learning process, not just a delivery process.
  10. Share learnings with the team. In your next retro or standup, share what you learned from the metric. This builds a culture where product thinking is valued, and others will start doing it too.

Common Mistakes

  • Jumping to solutions. It’s tempting to start coding immediately. But if you skip the problem definition, you risk building something nobody wants.
  • Ignoring the metric. If you don’t define success, you can’t learn. Even a simple metric like “number of clicks” is better than nothing.
  • Over-engineering. Product thinking means building the simplest thing that works. Adding unnecessary features increases complexity and maintenance burden.
  • Not talking to users. You might think you know what users want, but you’re often wrong. A quick chat can save weeks of work.
  • Treating product thinking as someone else’s job. Even if you have a product manager, your perspective as an engineer is valuable. You know what’s technically feasible and what might break.

Tips

  • Schedule a “product thinking” slot. Block 15 minutes at the start of each sprint to review upcoming work with a product lens.
  • Use a simple template. For each feature, write: Problem, Success metric, User flow, and Riskiest assumption. Share it in your ticket.
  • Pair with a designer or PM. If you have them, work together on user journey mapping. Different perspectives lead to better solutions.
  • Read your own analytics. If you have access to usage data, look at how users interact with existing features. This can spark ideas.
  • Celebrate small wins. When a metric improves because of your product thinking, share it. It reinforces the behavior.

Troubleshooting

  • You can’t find the user problem. Ask your PM or look at support tickets. If you still can’t, consider that the feature might be a technical debt or internal need—label it as such.
  • Your metric isn’t moving. Maybe the metric is wrong, or the feature isn’t solving the problem. Revisit your assumptions and talk to users to understand why.
  • Stakeholders push back on “thinking too much.” Frame it as saving time: “If we define the problem now, we avoid building the wrong thing.” Show a quick example of how it helped.
  • You feel overwhelmed by the process. Start small. Pick one feature per sprint to apply these steps to. It gets easier with practice.
  • Users don’t respond to your questions. Try different channels (in-app surveys, user interviews, or even just watching session recordings). Sometimes you need to observe behavior rather than ask.

Frequently Asked Questions

Do I need to be a product manager to do this?

No. Product thinking is a mindset, not a title. Engineers who understand the user are more valuable, and you can influence the product direction from the ground up.

How do I define a success metric if I don’t have analytics?

Start with a simple proxy. For example, if you’re building a search feature, you could count how many users click the first result. Even a manual count from user testing can work.

What if the feature is mandated by a client or executive?

You can still apply product thinking by asking “What problem is this solving for the client?” and then building it in a way that best serves that problem. You might even suggest a simpler alternative.

How do I balance product thinking with tight deadlines?

Product thinking actually saves time in the long run. Even 10 minutes of problem definition can prevent weeks of rework. If you’re really short, focus on the metric and the problem statement—skip the journey mapping.

Can I do this on a legacy project?

Yes, it’s even more important. Legacy code often has hidden assumptions about users. Applying product thinking can help you prioritize refactoring or new features that truly matter.

What if my team doesn’t care about product thinking?

Lead by example. Share your learnings and show how it improved your work. Over time, others may follow. Even if they don’t, you’ll feel more engaged in your work.

Related

General steps for current mainstream versions; menus can differ by device and version. See the disclaimer or report an error.

More in this bed

The whole Tech How-To bed →