Quality means doing it right when no one is looking.
— Henry Ford
Ford said this in a rather different context, but as a description of quality it goes back to the core definition: doing things right. Over many years of managing projects, we have learned to instinctively look for indicators or signs that stand for quality, so we can quickly size up the challenge in front of us. They don't fit every situation, so here we only cover the ones that work reasonably well most of the time.
Issue tracking
You are probably thinking: doesn't every project have this? We are not talking about the system itself, but about a few key behaviours in how it is run.
Issues reported to customer support are not shared with the development team
"Not shared" is putting it politely. In teams whose main product isn't software, most customer issues never reach the PM, and the ones that do have been filtered. In most org charts, development and customer support sit in different departments with different performance metrics, and whether issues are "fully" shared is certainly not one of them.
The consequence is that when trends in small issues can't be tracked properly, customers experience quality differently from how the development team sees it. Over time, the development process and planning become disconnected from quality, to a greater or lesser degree.
Severity assessment
Ever had this happen? The customer says "it's completely unusable", support says "people call about it every day", the PM says "it's probably just a small bug", and the developers reply "this needs a big architecture change, it won't be quick". Same issue, but everyone describes it differently, and their sense of how serious it is varies wildly.
The problem is the lack of a shared yardstick. Without a common way to judge severity, small things get blown up and big things get ignored. Over time, this blurs communication inside the team and pulls the outside experience of quality further away from the team's internal judgement.
Most projects have a "priority" field, but priority is mainly for scheduling: what to do first and what to do later. If issues have no severity assessment, priority easily gets misused to mean "how serious is it". These are two completely different things, and mixing them only makes the conversation more confused.
An experienced SQA will introduce strict severity definitions in a team. Besides stopping priority from distorting quality judgements, they are usually used to assess whether software quality is converging in the right direction. Not having severity assessment doesn't mean things are bad, it just means judging quality comes down to gut feeling.
If it can't be reproduced, it isn't recorded (or gets closed)
Many people have seen this: support or a user reports a problem, a developer tries it, can't reproduce it, marks it "cannot reproduce" and closes it. It looks reasonable, but it is actually risky.
"Cannot reproduce" does not mean "does not exist". Sometimes the conditions are just hard to trigger, or it only happens in a specific environment, and sometimes the developer's environment is simply different from most customers'. When these records disappear from the system, the team loses the chance to see trends. Many scattered small issues, if kept, often reveal a trend once enough of them pile up, and help the team put effort into problems before they happen at scale.
So what you really want to avoid is not "recording issues that can't be reproduced" but "letting them be ignored". Even if you can't solve it yet, leave the clues, so that later you have a chance to piece together the fuller picture.
Scattered records
It is less common now, but among our clients over the past year, nearly 1/4 of teams were still managing issues in Excel (or another spreadsheet). Every time I see it, I have to admire the team, because managing this way is genuinely hard, let alone keeping quality up over the long term. Some PMs really can run a whole project well in Excel, but in all these years I have met exactly one. Most projects managed this way wander through piles of spreadsheets, the team has a weaker shared picture, and of course quality is hard to guarantee.
Development process
As we said earlier, this article isn't asking you to understand the development process. We only cover quick ways to judge it, so don't worry and read on.
A clear start and end
In some projects, the team isn't really sure "what is this release supposed to include?" or "when does it count as done?". Without a clear start (which features are in) and end (what was actually delivered this time), quality checks become vague, because nobody knows what to check.
A simple test: is there a release plan that is visible internally, and after each release is there a release note you can track? These are not written only for developers. They let everyone see the project's rhythm and boundaries.
With a defined start and end, the scope is fixed, so at least we know whether a problem happened inside or outside the scope. If it is inside, we fix pre-release verification. If it is outside, we fix the development process and its rules.
Verification before and after release
A release is like moving into a new home: someone has to check that the lights turn on and the water runs. Many teams test internally during development, but if there is no transparent process for acceptance before and after release, in the end the only verification is customer complaints. So if every release brings in complaints, start by adding a simple, effective pre-release or post-release check.
People outside engineering can take part in this too. Just ask two simple questions:
1. Before release, is there a checklist?
2. After release, has anyone confirmed the key features still work?
Once these two steps become routine, the experience of quality changes a lot.
Regular retrospectives (Retro)
Many teams rush into the next round of work as soon as a project ends or a release ships, and the retrospective gets skipped. Without retrospectives, the team can only ever "fix the bug in front of it" and finds it hard to improve long-term quality.
The value of a retrospective isn't the ritual. It is a fixed time for everyone to bring up the problems they hit, the practices that worked, and even customer feedback. Only then does the team get a chance to adjust its process instead of falling into the same hole again and again.
In short, a retrospective is not a waste of time. It is the insurance that lets quality keep getting better.
Finally..
Quality has never been only the development team's responsibility. It reflects how the whole organisation collects issues, judges them and verifies what gets delivered. People outside engineering don't need to write code. Simple checkpoints in issue tracking and the development process are enough to tell quickly whether a project's quality is heading in the right direction.
Put another way, quality is not a set of numbers or reports. It is whether you can clearly see issues being recorded, understood and improved. When each of these keeps converging, quality truly stabilises.
If you are still not sure where to start, come and talk to us!
https://forms.gle/SpugbMsHQ4JgNfix8