
At 8:45 on Monday morning, a finance manager tries to export the invoices needed for a management meeting.
The export fails.
In a weak support setup, the customer submits a generic form, receives an automated acknowledgement and spends the next two hours answering questions that the application team could have captured at the start: which account is affected, which report they ran, when it failed and whether anybody else has the same problem. The ticket moves from support to engineering, back to support for more information, and then to another developer who asks the customer to reproduce it again.
The defect might ultimately be fixed, but the support experience has made the application feel far less dependable than the original technical problem alone would have.
A strong support operation handles the same situation differently.
The request arrives with useful context. Support determines that the problem affects an important business task, checks whether it is isolated or widespread, gives the customer a practical workaround if one exists, and escalates the technical investigation with enough evidence for engineering to begin diagnosing immediately. The customer knows who owns the issue and receives updates without repeatedly asking for them.
Once the underlying problem is fixed, the support case does not simply disappear. The team records what happened, links the issue to the application defect, and asks whether anything should change so the same problem is easier to detect or resolve next time.
That is good post-launch application support.
It is not simply answering tickets quickly.
Good post-launch application support gives users a dependable way to report problems, routes those problems according to their real impact, connects support with the people capable of resolving them, communicates clearly while work is underway, and turns recurring support issues into improvements to the application itself.
The GOV.UK Service Manual's guidance on user support makes an important point: support should not operate in isolation or exist only to react to problems. Feedback from support should help teams understand what is happening in the live service and decide what needs improving.
For Levelworks, this maps most directly to Supported App Health. A healthy application is not one in which users never encounter a problem; it is one where there is a reliable mechanism for understanding and resolving problems when they do occur.
Before launch, teams work largely with anticipated behavior.
After launch, thousands of real combinations begin appearing:
Some of those conditions expose defects that never appeared during development.
Others generate questions that are not defects at all.
A user may be unable to complete a task because of incorrect permissions. Another may misunderstand how a feature works. A third may have uncovered a genuine production bug, while a fourth is reporting the first symptom of a wider outage.
Good support exists partly to separate those situations efficiently.
This is also why application support and application maintenance are related but not identical.
Support is primarily concerned with helping users and managing the problems they experience. Maintenance changes the application to preserve or improve its condition over time.
The two need to connect, but they should not be confused.
[Internal Link: “Application Maintenance vs Application Support: What’s the Difference?”]
The first sign of weak post-launch support is often uncertainty about where a problem should go.
Should the user email their account manager?
Message a developer?
Submit a form?
Post in a shared Slack channel?
If several informal channels exist, support information becomes fragmented. The engineering team may know about one problem while the support team tracks another copy of the same issue somewhere else.
A clear intake process creates a system of record.
That might be a service portal, email-to-ticket system, in-app support function or another structured channel appropriate to the product.
The channel matters less than what happens after the request enters it.
Atlassian's Jira Service Management documentation, for example, uses structured request types to route incoming requests into appropriate queues and categories rather than treating every contact as identical. Atlassian: Request types in IT service management
A support request should ideally capture enough information to begin investigation without forcing the customer through unnecessary questioning.
“Reports don't work” is not a useful technical problem description.
A better support record might say:
Invoice export fails for Customer 4819 when filtering dates from September 1–30. User receives an HTTP 500 after approximately 12 seconds. Issue reproduced twice at 09:04 IST in Chrome 141. Other reports still work.
The difference is enormous.
Useful context often includes:
AWS uses a similar model for technical support cases, asking customers to provide the who, what, when, where, why and how of an issue, including business impact, symptoms, what has already been tried and reproduction information. AWS Support: Creating an effective support case
Better intake reduces the time between “someone reported something” and “someone capable of solving it understands the problem.”
A support queue should not simply operate first-in, first-out.
Consider two tickets:
Ticket A: One administrator cannot change the color of an optional dashboard widget.
Ticket B: All customers using a particular payment method are unable to complete checkout.
Ticket B arrived ten minutes later.
It should still move first.
Support teams need a simple severity or priority model based on factors such as:
AWS's support model similarly distinguishes severity according to the operational impact of a problem, ranging from general guidance to production or business-critical systems being unavailable. AWS Support severity levels
The exact labels matter less than consistently distinguishing inconvenience from genuine business interruption.
A detailed prioritization framework belongs elsewhere in the Levelworks series.
[Internal Link: “How to Prioritize Bugs, User Issues and Feature Requests”]
Not every support case should follow the same path.
A useful support operation distinguishes at least between:
User questions
The product is behaving correctly, but the user needs information or guidance.
Defects
Application behavior does not match what is intended.
Incidents
An unexpected event is currently disrupting service for multiple users or an important production capability.
Recurring problems
Several seemingly separate incidents or tickets may share the same underlying cause.
Atlassian's service-management model similarly separates service requests, incidents, problems, changes and post-incident work because each requires different handling. Atlassian: ITSM work categories
This distinction prevents a significant production outage from being handled like a routine support question and stops recurring defects from being treated indefinitely as unrelated tickets.
One of the worst support experiences is being transferred between internal teams.
From the customer's perspective:
“Support says engineering owns it.”
“Engineering says the infrastructure provider is investigating.”
“The account team says to contact support.”
Those organizational boundaries should not become the customer's responsibility.
A strong support model keeps one clear owner for the customer-facing case even when technical work moves elsewhere.
The support owner should know:
Engineering may own the root-cause investigation.
Infrastructure may own a platform issue.
A vendor may ultimately need to correct a third-party defect.
The user should still have one reliable place to understand what is happening.
A good escalation adds capability.
A bad escalation simply adds another person.
Support tiers can be useful when they reflect different technical depth. For example, frontline support may handle known issues and account questions, while application specialists reproduce product defects and engineering investigates problems requiring code changes.
The important requirement is context continuity.
When a case moves to another team, the next responder should inherit:
The customer should not repeatedly reconstruct the same story.
Zendesk describes escalation as moving a support interaction to somebody with the appropriate authority or specialist expertise, with the objective of getting the correct people involved sooner. Zendesk: Identifying and acting on ticket escalations
Good escalation shortens the path to resolution rather than resetting it.
Most support tickets do not need a war room.
Some do.
If support detects that many users are reporting the same failure, the problem may need to move from ordinary ticket handling into incident response.
At that point, responsibilities change.
Someone needs to coordinate technical response, someone needs to manage communication, and responders need a shared understanding of what is happening.
Google's Site Reliability Engineering guidance describes effective incident management around three core responsibilities: coordinate the response, communicate between responders and stakeholders, and maintain control of the incident. Google SRE: Incident Response
Support plays an important role because it may be where the first pattern becomes visible.
Ten customers reporting failed uploads within five minutes should not remain ten independent support tickets if they are all symptoms of the same production failure.
The detailed operational response to that situation belongs in the dedicated incident-response article.
[Internal Link: “Application Incident Response: What Should Happen When Your App Goes Down?”]
Silence makes unresolved problems feel worse.
A customer can often tolerate waiting for a difficult technical issue if they know:
What frustrates customers is having to repeatedly ask:
“Any update?”
Good support communication does not require predicting a resolution time engineers cannot confidently provide.
There is a difference between:
“This will definitely be fixed within 30 minutes.”
and:
“Engineering has reproduced the issue and is investigating the database query involved. We will update you again by 14:00 even if the investigation is still in progress.”
The second message makes a commitment the team can actually control: communication.
During larger incidents, Google's SRE guidance explicitly assigns communication as a distinct responsibility because technical recovery and stakeholder communication both need attention.
That principle applies at smaller scale too.
Support teams become very good at workarounds.
Refresh the page first.
Export one month at a time.
Disable this setting before uploading.
Log out and back in.
These instructions can be valuable when they get a customer working again quickly.
The danger is allowing them to become permanent substitutes for correcting the application.
If 40 customers have received the same workaround, the organization probably does not have 40 separate support problems.
It has one product problem.
Atlassian's description of problem management makes this distinction explicitly: teams can document workarounds to reduce disruption while the underlying cause is investigated and ultimately corrected. Atlassian: Problem management process
Good support restores the user quickly where possible, but it also makes recurring workarounds visible to the teams responsible for eliminating their cause.
Support is one of the richest sources of information about a live application.
If customers repeatedly ask:
“Where do I change the billing contact?”
the problem might be documentation.
Or navigation.
Or terminology.
If they repeatedly report that imports fail after 50,000 rows, that may be a technical limitation nobody has properly surfaced.
The GOV.UK Service Manual recommends treating enquiries as potential faults and using support data to improve the underlying service rather than seeing the support desk purely as a response function.
A mature support loop looks like:
User contact
↓
Support diagnosis
↓
Pattern identified
↓
Product / engineering investigation
↓
Application improvement
↓
Fewer future contacts
This is where Supported App Health connects naturally with the wider condition of the application.
Support should absorb unavoidable customer problems.
It should not permanently absorb avoidable product problems.
Some questions genuinely do not require engineering involvement.
Users may repeatedly need help with:
Once support has solved the same problem several times, the organization should consider whether the answer belongs in reusable documentation.
A knowledge base can benefit both customers and support staff, provided the information remains accurate.
Atlassian's service-management guidance describes knowledge-base articles as a way to provide troubleshooting guidance and answers to common questions so customers can sometimes resolve issues without raising a new request. Atlassian: Help resources and knowledge-base articles
Documentation should not be used to hide poor UX behind instructions.
If the application itself can reasonably prevent the confusion, fixing the product is better.
But for genuinely complex or infrequent tasks, good knowledge prevents every user and every new support engineer from starting again from zero.
[Internal Link: “Why Good Documentation Makes an App Cheaper to Maintain”]
Ticket count alone says very little about whether support is good.
A growing product may receive more tickets simply because it has more customers.
A declining ticket count may even be bad news if customers have stopped expecting useful responses.
Useful support measures depend on the application, but can include:
Measure
What it helps reveal
Time to first meaningful response
How long users wait before useful engagement begins
Time to resolution
How long problems remain unresolved
Reopened tickets
Whether apparent resolutions actually held
Escalation rate
How frequently frontline support needs deeper expertise
Repeat issue volume
Which problems continue generating demand
Tickets by feature
Where customers encounter the most friction
Resolution without escalation
Whether support has enough knowledge and tooling
Customer feedback after resolution
How users experienced the support process
The GOV.UK Service Manual recommends measuring support demand, response time and handling time, and then using that information to improve the service and staffing model.
Do not optimize one metric in isolation.
A team can reduce average handling time by closing difficult tickets quickly without actually solving them.
Support metrics should reflect whether users get useful outcomes, not simply whether tickets disappear from a queue.
Support becomes dramatically more effective when responders can see enough application context to distinguish user error from product failure.
Depending on security and privacy requirements, useful support tooling might expose:
This does not mean giving every support agent unrestricted production access.
It means designing safe tools that help support investigate without asking engineering to look up basic information for every ticket.
The GOV.UK guidance on monitoring live services recommends tracking application problems in a ticketing system and maintaining operational documentation that helps teams respond quickly. GOV.UK: Monitoring the status of your service
When support can connect a customer's report to observable system behavior, diagnosis becomes faster and less speculative.
A mature support flow can be surprisingly simple:
That is more important than having a large support organization.
A smaller team with strong ownership, context and escalation can provide better application support than a larger team that simply moves tickets through queues.
Once software goes live, users begin discovering things that no pre-launch test environment can reveal completely.
Good post-launch support gives the organization a structured way to hear those signals.
It helps a customer solve the immediate problem, but it also asks what the problem reveals about the application.
Was this an isolated question?
A defect?
A wider incident?
A confusing workflow?
A recurring failure that should already have been fixed?
For Levelworks, this is why Supported is an App Health aspect in its own right.
A healthy application needs more than code that currently runs. Users need a dependable route to help when reality diverges from what the product team expected, and the organization needs a mechanism for turning those interactions into better understanding of the live application.
Good post-launch support therefore is not measured by how efficiently a team can make tickets disappear.
It is measured by whether users can get from “something is wrong” to “I understand what is happening, somebody owns it, and I can move forward” without having to navigate the internal structure of the company themselves.