Kent Wynn

Product

Practical Lessons in Product: Real-World Insights for Engineers

Building successful products requires more than just great code. Kent Wynn shares practical lessons from years of experience, covering user research, iteration, and balancing technical debt with business goals.

By Kent Wynn·
Product ManagementUser ExperienceTechnical DebtAgileSoftware EngineeringAi Integration

Building successful products requires more than just great code. As a senior engineer, I’ve learned that product success hinges on a blend of technical rigor, user empathy, and strategic vision. Over the years, I’ve distilled several practical lessons that have shaped how I approach product development. These insights—rooted in real-world challenges and wins—aim to help engineers and product leaders navigate the complex intersection of code, people, and business.

The Importance of User Research (Even When It’s Hard)

One of the most common pitfalls I’ve seen is assuming you know what users want. As an engineer, it’s easy to fall into the trap of building features based on technical feasibility rather than user needs. But the most effective products are built by deeply understanding the why behind user behavior.

I’ve spent countless hours conducting user interviews, analyzing behavior data, and even shadowing users in their workflows. A critical lesson here is to start small: use lightweight tools like surveys or A/B testing to validate assumptions before investing heavily in development. For example, when redesigning a dashboard for a B2B tool, I initially built a complex interface with dozens of widgets. After a week of user testing, it became clear the feature was overwhelming. We pivoted to a minimalist design, which improved adoption by 40%.

User research isn’t a one-time task—it’s an ongoing process. Treat it like a scientific experiment: hypothesis, test, iterate. Tools like Hotjar or Figma’s user testing features can provide actionable insights without requiring a full UX team.

Embracing Iterative Development (And Letting Go of Perfection)

Another lesson I’ve learned the hard way is the value of iterative development. In my early days, I’d spend months perfecting a feature, only to see it fail because it didn’t align with user needs. The key is to build a minimum viable product (MVP) that solves a specific problem, then refine it based on feedback.

Here’s a simple example: When developing a feature to automate report generation, I initially tried to build a complex system with custom templates and advanced filters. It took three months and required a full rewrite when the client’s requirements changed. Instead, I adopted an iterative approach:

  1. Built a basic version with core functionality
  2. Tested it with a small group of users
  3. Added features based on real feedback

This approach reduced development time by 60% and ensured the final product met user needs.

Iterative development also means being okay with imperfection. A feature that’s “good enough” today is better than one that’s “perfect” tomorrow. Prioritize speed and adaptability over polish—users will reward you for that.

Balancing Technical Debt and Business Goals

Technical debt is inevitable, but how you manage it defines your product’s long-term health. I’ve seen teams fall into the trap of ignoring debt in favor of quick wins, only to face a crisis months later. The key is to prioritize debt reduction based on business impact.

For example, when refactoring a legacy codebase, I used a risk-based approach:

  1. Identified modules with the highest bug rates
  2. Focused on improving test coverage and readability first
  3. Deferred less critical changes to later sprints

This strategy reduced critical bugs by 35% without disrupting ongoing development.

Here’s a simple code example of a refactored function to illustrate the point:

// Before: Hardcoded logic with poor readability
function calculateDiscount(price: number): number {
  if (price > 1000) {
    return price * 0.2;
  } else if (price > 500) {
    return price * 0.15;
  } else {
    return price * 0.1;
  }
}

// After: Clear logic with better maintainability
function calculateDiscount(price: number): number {
  const discountRate = price > 1000 ? 0.2 : price > 500 ? 0.15 : 0.1;
  return price * discountRate;
}

The refactored version improves readability and makes future changes easier. Technical debt is not something to avoid—it’s a cost to manage strategically.

The Role of AI in Modern Product Design

Finally, I’ve learned that AI is no longer a futuristic concept—it’s a tool that can enhance product design when used thoughtfully. However, the key is to avoid overengineering. I’ve seen teams waste time building complex AI models for simple tasks, only to realize the solution could have been achieved with simpler code.

A recent project highlighted this lesson. We wanted to automate data analysis for a client, so I initially proposed a machine learning model. After a week of prototyping, we realized a simple rule-based system would suffice. The AI approach added unnecessary complexity and delayed delivery.

When integrating AI, ask:

  1. Does this solve a problem that’s hard to automate?
  2. Can we achieve the same result with simpler tools?
  3. What’s the cost of getting this wrong?

AI should augment, not replace, human insight. Use it to handle repetitive tasks, not to complicate the user experience.

Conclusion

Product development is as much about people and strategy as it is about code. The lessons I’ve shared—user research, iterative development, technical debt management, and thoughtful AI integration—are not silver bullets, but they’ve helped me build better products over time.

If you’re an engineer or product leader, I encourage you to lean into these principles. Build with empathy, iterate with purpose, and always keep the user at the center. The most successful products are those that solve real problems, not just technical ones.

← Back to Blog