Building a product for external customers requires a broader perspective than creating solutions for internal teams. It involves thinking about its delivery, understanding why decisions are made, how people use this product, what impact can it have, and how that can be measured. Software developers working on user-facing products can become more product-minded by:
- Understanding how and why their company is successful. What's the business model, how is money made, which areas are most profitable, and why?
- Building a strong relationship with product managers. Clear communication that allows management to scale their efforts and that is open to regular feedback.
- Engaging with the product itself by using it, providing customer support, or collaborating with user research. Get involved in activities that force you to learn how the product works in real situations.
- Bringing feasible product suggestions to the table. Take the initiative to suggest improvements in projects you're working on or suggest a larger effort by outlining work and helping prioritize it in the team's backlog.
- Offering product/engineering tradeoffs for projects. Suggest product tradeoffs that reduce development efforts, as well as development tradeoffs for important features.
Developers can therefore become key contributors to a product's solid success as they leverage the following traits:
Proactive with product ideas and opinions. Instead of settling for merely implementing a specification they receive, they consider alternatives and approach the product manager with them.
Interest in the business, user behavior, and relevant data. They dive straight into business and user data by accessing it directly if possible, or via the product manager and data scientists.
Curiosity and a keen interest in "why?" Questions like "why build this feature but not another one?" are raised in the context of strong relationships developed with product managers.
Pragmatic handling of edge cases. They're focused on the "minimum lovable product" concept and offer good middle-ground suggestions by mapping what can go wrong, even before shipping an early version.
Quick product validation cycles. Before a feature they're working on hits production, product-minded software developers find creative ways to get early feedback and step-by-step validation.
End-to-end product feature ownership. They often only consider their work "done" after getting user behavior and business metrics post-rollout.
These are notes I've taken from "The Software Engineer's Guidebook" by Gergely Orosz in his chapter regarding how we can thrive in different project environments. This particular mindset resonates with my appreciation for software craftsmanship as an iterative creative process that always tries to reach for the best palpable solution. By learning from what we're doing while remaining aware of the whole landscape, we can try to avoid getting stuck on local maximums. Only by finding the right problem to solve can we get to that surprisingly better solution.