Skip to main content
Published in Product Insights

Best Practices in Product Engineering

Best Practices in Product Engineering
Table of contents
  1. Enhancing Product Engineering
    1. Agile Methodologies
    2. Continuous Improvement
  2. What is product engineering, and who should own it?
  3. How do you measure product engineering?
  4. How small and how often should releases be?
  5. How do real users change what gets built?
  6. How do you keep the code healthy: reviews, technical debt and documentation?
  7. How do you judge a partner's product engineering practices?
  8. Should you build the team in-house or use a partner?

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.

MetricWhat DORA measuresGroup
Change lead timeThe time for a change to go from committed to version control to deployed in productionThroughput
Deployment frequencyThe number of deployments over a given period, or the time between deploymentsThroughput
Failed deployment recovery timeThe time to recover from a deployment that fails and needs immediate interventionThroughput
Change fail rateThe ratio of deployments that need immediate intervention, likely a rollback or a hotfixInstability
Deployment rework rateThe ratio of deployments that are unplanned and happen because of an incident in productionInstability

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.

  1. Does each change do one thing?
  2. Did someone other than the author approve it?
  3. Did the automated tests run and pass before the merge?
  4. Has the team practiced a rollback before it needed one?
  5. 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.

SignalQuestion it answersWhen to look
Conversations with usersWhy do people work the way they do?Before a large decision, and after a release they use
Usage inside the productWhat do people actually do, and where do they stop?Every week, next to the business number
Support ticketsWhat 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.

PracticeAsk the partnerA warning sign
A plan before a priceCan we see a plan from a past project, with milestones and prices?A full price before anyone has studied your systems
Code reviewWho reviews each change, and can authors approve their own?Reviews are optional, or authors approve their own work
TestsWhich tests must pass before a release goes out?Testing happens by hand at the end, and nothing blocks a release
Code ownershipWhose repository holds the code, from the first day?The code stays in the partner's account until the final invoice
Price changesWhat happens to the price when the work runs over?Every overage is billed to you by the hour
Defects after launchWho 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.

Frequently asked questions

How do agile methods help product engineering?

They support iterative work, faster feedback and adjustments. They also encourage collaboration and improve product quality.

What practices support continuous improvement?

Gather user feedback to inform design, invest in training to keep up with technology, and maintain clear documentation for sharing knowledge.

What is product engineering?

Product engineering is the work of turning a business need into software people use, then keeping it useful after launch. It covers what to build, how to build and release it, and how to learn from users. One team owns the result, and one person on the business side owns the product.

How do you measure product engineering performance?

Use DORA's five software delivery metrics, which are change lead time, deployment frequency, failed deployment recovery time, change fail rate and deployment rework rate. Track them for one application at a time. Add one business number the product moves. Do not set the DORA metrics as goals, because teams are then more likely to game them.

How often should a product team release software?

Release as often as the team can ship small changes and roll them back safely. DORA names smaller batches of change as a common way to improve all five of its delivery metrics. The Agile Manifesto asks for working software every couple of weeks to a couple of months, preferring the shorter timescale.

Who should own the product when a partner builds it?

Someone on your side should own it. A partner can design, build and maintain the software, but ownership stays with an employee who can make decisions that stick. That person knows the users, sets priorities and joins reviews and demos, not only kickoff and launch.

How do you evaluate a product engineering partner?

Ask the partner to show a past plan, code reviews, release tests and contract terms. At The Gnar Company, Gnar Discovery and Design costs $15,000, $20,000 or $30,000 for two, four or six weeks. 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.

Should a mid-market company build product engineering in-house?

Build in-house when your engineers have both the capacity and the direction for the work, and use a partner when one is missing. The Gnar Company tells buyers who already have engineers: "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."

Stay In The Loop

Never miss an update. Get the latest blogs, webinars, and expert insights straight to your inbox from The Gnar.