Who is responsible to look into client reported issues

Question

In our organisation we deliver products to different product lines depending on the requirements. in short the same application is customised according to customer requirements and delivered. After deploying the application sometimes we got some issues logged by client.

My question comes here. who is responsible to look into the issues and solve it

• Programmers
• Testers

Management is asking Testers to have a look into the issues and solve them. But the testers don't have the chance to look into the code. is it feasible to ask the testers to go for the issue resolution and end up wasting time doing nothing thus delaying the solution to the customers.

Answer 1

I would normally expect management to look through the issues every so often (say, every week), and allocate depending on schedules, severity, forthcoming releases etc. Some questions are:

1. is it an issue a bug, a feature request etc.?
2. does it prevent your client from working with your tool ?
3. is it impacted by forthcoming work (e.g. will a new feature remove the feature causing the issue) ?

I don't believe you can resolve these issues in isolation. It requires project managers etc. with awareness of project direction and programmers with awareness of the codebase to work together to determine how/when issues should be addressed, and their impact on other work streams.

Answer 2

Initially you should have a support department that does triage on all newly added issues. They should be empowered and informed enough to decide whether this is a non-issue, whether there's a work-around or whether they don't know. If it's the latter then it should be elevated to programmers.

You might also want to include the testers in the chain if the support guys are unable to produce an adequate 'how to reproduce the problem' document for the programmers.

Answer 3

Testers can identify an issue. How can they resolve the same? Only the developer will be able to do it. Looks really strange where a tester is asked to resolve the issue.

Answer 4

The way it works at our company is that the testers are asked to verify the client's issue, i.e. trying to reproduce it and document the steps taken to reproduce it. Then it gets logged as an official bug and assigned to a developer who can retake the tester's steps and hopefully fix the bug.

Answer 5

Who deals with the clients? Liasing with clients is not a task normally associated with the technical staff.

You should have someone whose role it is to speak to the customers, find out exactly what the issue is and how the client would like it resolved so that it may be passed onto the most relevant person to address the issue.

Answer 6

I would say the logical way to do it is:

• Testers should try to reproduce the problem and identify its source
• Report the problem with steps to reproduce it to the programmers

It's not common usage to let testers solve the issues as the programmers won't get the feedback they need to avoid the issues in the future.

Answer 7

Testers - verify that the problem exists. Programmers - solve the problem.

In between there is another part to this, which is "gather information about the problem". Usually this is a split between testers and programmers; exactly how balanced that load is depends on the team.

If you don't have the code, you can't fix bugs. It's as simple as that. At the very most you could fix configuration errors, but if the misconfiguration was caused by the program that's a short-term fix.