Enhancing Product Engineering#
To achieve excellence in product engineering, organizations must adopt best practices that streamline processes and improve outcomes. This article outlines several effective strategies.
Agile Methodologies#
Implementing agile methodologies allows teams to work in iterative cycles, enabling faster feedback and adjustments. This approach fosters collaboration and enhances product quality.
Agility leads to better responsiveness to customer needs.
Continuous Improvement#
- Feedback Loops: Regularly gathering feedback from users to inform design decisions.
- Training and Development: Investing in team skills to keep pace with technological advancements.
- Documentation: Maintaining clear documentation to facilitate knowledge sharing.
By embracing these best practices, companies can significantly improve their product engineering efforts and deliver superior products to the market.
What is product engineering, and who should own it?#
Product engineering is the work of turning a business need into software people use, then keeping it useful after launch. One team owns the result, from the first idea through support. One person on your side owns the product and makes the calls. Without that person, a good team can still build the wrong thing.
The work is wider than writing code. It covers what to build, how to build and release it, and how to learn from users. It can come from an internal team, a partner or both. The Gnar Company does this work for clients as custom software development.
The Agile Manifesto sets the working rule: "Business people and developers must work together daily throughout the project." Daily work with developers needs a named person on the business side. That person stays inside your company, even when a partner writes the code. A Gnar post on the minimum viable technical team puts it plainly: "You can outsource nearly anything: development, design, maintenance. But you can't outsource ownership."
Use four tests to check whether you have that owner. The first three follow the real product owner described in the Gnar post Do You Actually Have a Product Owner?
- Authority: they make product decisions without a chain of approvals. In the post's words, "When they make a choice, it sticks."
- Knowledge: they know the product, its users and its limits well enough to talk with engineers.
- Decision-making skills: they weigh user needs, business goals and technical limits before they decide.
- Time: they show up for reviews and demos, not only for kickoff and launch.
If one of these tests fails, fix it before you add engineers.
How do you measure product engineering?#
Measure delivery with DORA's five software delivery metrics, tracked for each application on its own. Then put one business number next to them, such as orders processed or hours of manual work removed. DORA's numbers show whether the team ships safely. The business number shows whether the shipping matters to the company.
The DORA metrics guide splits the five metrics into two groups. Throughput is how many changes move through the system. Instability is how well the deployments go.
| Metric | What DORA measures | Group |
|---|---|---|
| Change lead time | The time for a change to go from committed to version control to deployed in production | Throughput |
| Deployment frequency | The number of deployments over a given period, or the time between deployments | Throughput |
| Failed deployment recovery time | The time to recover from a deployment that fails and needs immediate intervention | Throughput |
| Change fail rate | The ratio of deployments that need immediate intervention, likely a rollback or a hotfix | Instability |
| Deployment rework rate | The ratio of deployments that are unplanned and happen because of an incident in production | Instability |
Three rules from the same guide keep the numbers honest.
- One application at a time. DORA says the metrics are "best suited for measuring one application or service at a time." Blending teams into one number hides real differences.
- Speed and stability move together. DORA's research found that "speed and stability are not tradeoffs." If one improves while the other slides, look closer.
- Do not set the DORA metrics as goals. DORA warns that setting metrics as goals makes teams more likely to game them.
You do not need a large data project to start. DORA says that building integrations to many systems for precise data "might not be worth the initial investment." Its guide suggests a simpler routine. Gather the team that builds and runs the application. Set a baseline with the DORA Quick Check. Talk through where delivery gets stuck. Then have the whole team commit to improving the biggest constraint first. Smaller measures can help along the way, such as how long code reviews take.
The business number belongs where your leaders already look. For Laborocity, a job marketplace that helps warehouses hire, The Gnar Company built dashboards "that included KPIs, so Laborocity management could monitor the business with one click." Ask any team, in-house or partner, where your business number will show up.
How small and how often should releases be?#
Keep each change small enough for one reviewer to read in one sitting. Release as often as the team can safely roll back. DORA names "reducing the batch size of changes" as a common approach to improving all five of its metrics. Smaller changes are easier to move through delivery and easier to recover from.
The Agile Manifesto asks teams to "Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale." Small changes make that possible. Google's engineering practices list what small changes buy you. They are "Reviewed more thoroughly," "Less likely to introduce bugs" and "Simpler to roll back."
A Gnar engineering post, Our Code Review Process, applies the same habit to larger projects: "we break them down into the smallest units possible." It also sets one rule for every change: "the reviewer who provides final approval cannot be the author."
Ask your team five questions about how it releases.
- Does each change do one thing?
- Did someone other than the author approve it?
- Did the automated tests run and pass before the merge?
- Has the team practiced a rollback before it needed one?
- Is there a written note of what changed, so support staff know what users will see?
How do real users change what gets built?#
Put working software in front of real users early, then let what they do set the next step. Opinions in a meeting are guesses. Usage, support tickets and short conversations with users are evidence. The Agile Manifesto principle on progress reads: "Working software is the primary measure of progress."
This post's own list starts with the habit: "Feedback Loops: Regularly gathering feedback from users to inform design decisions." The hard part is choosing which signals to read, and when.
| Signal | Question it answers | When to look |
|---|---|---|
| Conversations with users | Why do people work the way they do? | Before a large decision, and after a release they use |
| Usage inside the product | What do people actually do, and where do they stop? | Every week, next to the business number |
| Support tickets | What breaks or confuses people today? | Every week, sorted by how often each issue repeats |
One rule ties these together. Before the next large decision, put something users can touch in front of them. A clickable prototype is enough.
Testing with users can be designed into the product from the start. On the Qeepsake mobile app, The Gnar Company's case study says: "We designed the UX with clear business goals in mind: i.e., optimizing conversion rate for launch and enabling continuous A/B testing of Qeepsake’s offerings and pricing."
How do you keep the code healthy: reviews, technical debt and documentation?#
Healthy code gets reviewed, tested, kept up to date, tracked for debt and documented. Check it by asking five questions of any codebase, yours or a partner's, and treat each "no" as a cost someone will pay later.
- Is every change reviewed before it merges?
- Do automated tests cover the parts of the system that bring in money?
- Can the team update its libraries and frameworks, or is it stuck on old versions?
- Is technical debt written down, with a rough size for each item?
- Could a new team pick up the code from its documentation?
Google's reviewer guide says reviewers should favor approving a change once "it definitely improves the overall code health of the system being worked on, even if the CL isn’t perfect." A CL is Google's word for a single change.
Debt gets paid down in steps. A Gnar post, Paying Down Technical Debt, says: "Setting reasonable and achievable goals will be more effective than trying to resolve all of the accumulated debt at once." The same post names the hard part: "The only way to allot this time is by getting buy-in from the stakeholders." Giving that buy-in is an executive's job.
Documentation matters most at hand-off. The Gnar Company's custom software development page states it in one line: "The codebase is yours, in your repository, documented for hand-off." Ask any partner to put the same line in writing.
How do you judge a partner's product engineering practices?#
Ask the partner to show you each practice at work before you sign. A plan, a code review, a test run and the contract terms are all things you can look at before you sign. If a partner cannot show one of them, treat that practice as missing.
Use this table during the sales process. Each row is one practice, one request and one warning sign.
| Practice | Ask the partner | A warning sign |
|---|---|---|
| A plan before a price | Can we see a plan from a past project, with milestones and prices? | A full price before anyone has studied your systems |
| Code review | Who reviews each change, and can authors approve their own? | Reviews are optional, or authors approve their own work |
| Tests | Which tests must pass before a release goes out? | Testing happens by hand at the end, and nothing blocks a release |
| Code ownership | Whose repository holds the code, from the first day? | The code stays in the partner's account until the final invoice |
| Price changes | What happens to the price when the work runs over? | Every overage is billed to you by the hour |
| Defects after launch | Who fixes bugs found after launch, and for how long? | Fixes after launch need a new contract |
At The Gnar Company, the plan comes first, in a step called Gnar Discovery and Design. Discovery costs $15,000, $20,000 or $30,000 for two, four or six weeks. According to the How We Work page, a build is typically $150K to $300K+, at a fixed milestone price set at the end of Discovery.
The Gnar Company answers the price and defect rows in its contract. Three commitments on every build engagement: a fixed milestone price with any overage on us, a guaranteed outcome meaning the software works as specified or we fix it, and a twelve-month bug-free warranty. It covers Discovery, Build, Forge and Maintain. It does not cover Embed. On Compass, Immerse and Integrate, ask us.
If a partner says it builds with AI agents, every row above still applies, plus the questions in Agentic Software Development: What Buyers Should Ask.
Should you build the team in-house or use a partner?#
Build in-house when your engineers have both the capacity and the direction for the work. Use a partner when one of the two is missing. A third option splits the work: a partner plans and builds, then your own team takes over the running product.
The Gnar Company gives the same advice to buyers who already have engineers on staff: "Often you should use them. If your own engineers have the capacity and the direction, do it internally and we will say so on the call."
Signs the work belongs in-house:
- Your engineers have open time on the roadmap for this work.
- Someone on the team has built and run this kind of software before.
- The product owner already works closely with the engineers.
Signs a partner fits better:
- Your engineers are fully booked on the systems that keep the business running.
- Nobody on staff has built this kind of system before.
- Your leadership wants a fixed price before it approves the work.
The split option works only if the hand-off is planned from the first day. The code should sit in your repository from the start. Your engineers should join code reviews before launch. The documentation should be written for your engineers.


