Dcode Group Blog

Managing User Feedback in our Custom Software Development

When we develop software (be it custom or off-the-shelf), client feedback is invaluable to ensuring our solutions are fit for purpose. But ensuring that this feedback is clear can often be a difficult process. So that's why we developed our Kanopi feedback widget - a tool we now install on all our software for clear and concise sharing of feedback in cloud-based software.

When developing software, there are a number of stakeholders in the process. The Client, Designers, Developers, Project Managers, External Agencies and then even stakeholders of the Clients themselves. Managing the requirements, comments and feedbacks of all these parties can be a time consuming process. But the importance of collecting and addressing the feedback from these users is instrumental in ensuring that software can be developed that will be adopted and used by all.

So we decided to take a look at how we manage User Feedback at Dcode Group and what we could do to improve the process and the outcomes for all concerned.


Issues with User Feedback in Software Development

The biggest issue with obtaining feedback in Software Development is how to clearly convey the issue/comment. Its not always easy to "show" someone the problem without spending considerable time capturing step-by-step screenshots, URLs, images, etc. Sometimes a simple comment just isn't clear as to what the issue or problem relates to. But this in itself can become a barrier to a User submitting a comment - instead reverting to firing off an email with their queries.

In addition, sometimes the problem/issue only persists on certain pages - rather than a system wide problem. And conveying this is often difficult for a non-technical User to diagnose.

We also find that when working with a range of Users, its not always easy to clearly mandate a list of information to provide that will help us as developers diagnose the problem. Users often don't know what information is important to get across their feedback.

Once we do get the feedback, collating and managing the Tasks can provde difficult - especially if these are being submitted from different sources.

 

Problems we faced Capturing Customer Feedback

We tried a number of solutions to capture feedback - from off-the-shelf solutions; to Excel registers; to email updates and more. But we encountered a number of issues in this process:

  • The tools we tried to use had API limits that meant data sharing was often not working well;
  • Managing an additional register to our systems often meant double handling of information;
  • The lack of consistency across our business often meant inefficiency; and
  • While some Users were clear on feedback processes - there was no constency/sharing of learnings across the wider team.

 

Goals We Set

So we decided to try a different approach. As custom software developers, we provide solutions for our clients' every day. This was a problem that we were determined to find a better solution.

The key things we wanted to achieve was:

  1. A simple method to capture User feedback on our projects in a consustent way;
  2. The system would have to be simple enough to be used by Users of our platform - without having to explain the process;
  3. The feedback would need to include enough information for us to be able to resolvbe the issue;
  4. The feedback would need to create a Task to manage the workflow; and
  5. A feedback loop would be requried to seek confirmation from the User at the end of the process.

And this is how we started the development of our Feedback Widget for Kanopi.

 

How We Capture User Feedback

We developed a feedback widget based on our project management system, Kanopi, that can be easily embeded into our software solution - either software written by us; or off-the-shelf software. Using this tool, Users logged into Kanopi can now see a Feedback icon on each platform we develop (only when logged into Kanopi).

Managing feedback using our Kanopi Widget

When activating this widget; a User can submit feedback (along with annotations and attachments) that will immediately create a Ticket in Kanopi alongside the corresponding project. When collecting this feedback, we automatically grab a screenshot of the current window to allow the User to add annotations to their feedback.

Using the Kanopi Widget to Capture Annotations

And when the feedback is submitted; we can review and manage the requriements in our normal workflows.

 

What Do We Capture

The capture itself was designed with a number of our goals in mind - being simple; but providing enough information for us to understand the feedback. In that regard, we're capturing two sets of data:

  1. User submitted data; and
  2. Automated diagnostics.

From the User, we're obtaining:

  • Feedback;
  • Attachments; and
  • Annotations of the screenshot.

What we capture from Users

In the background, we're also adding:

  • The User that made the request;
  • The URL that request was made on; and
  • The screenshot of the request.

In this process, we now have a clear idea of what the User was doing; where they were on the software; what they saw; along with annotations of the screenshot for additional clarity. This ensures we get enough information to clearly identify the issue, page, site area and problem. A much more steamlined approach.

 

Managing Customer Feedback

With the feedback now managed in a consistent way and Tasks now sent directly to our Project Management System; the process of managing the feedback has been simplified immensely. Our feedback is now collated in the one place and we can collaborate with Users within Kanopi itself.

The Tasks are categoriesed and assigend to team members within Kanopi and we can work through the requirements - with discussions on the Task that can be shared with the User.

The User has access to their Projects in Kanopi - so have visibility on our workflow and can contribute to our queries in the one place. This ensures nothing gets missed.

 

Implementing Changes and Review

Once we've implemented feedback; we can then assign the Task back to the User to confirm that the issues raised have been addressed and the feedback can be closed. This way we can complete the full cycle of managing the enquiry of the User and ensure that the changes are consistent with requests; and do indeed meet the needs of the User.

All in all, a much more structured and encompassing approach that ensures we capture and manager feedback more effectively.


What's Next?

As we grow the tool and improve its implementation; we will undoubtably find ways to improve the system. But the upside is that we can implement and manage this as the setup (from end-to-end) has been designed and developed by us.

Just like when we develop our software; we'll seek feedback from our stakeholders. And we look forward to continually improving the way we manage Customer Feedback in our applications!

Written by

Andrew Sirianni

Andrew founded DCODE GROUP with the goal to develop custom software solutions...