Apply for class 03 now!

Nextcloud app developement: A room in a finished building

  • From the projects
  • Image by Steffi Timm // Pixabay

The TicketCheck project, part of class 02, is developing a helpdesk app for Nextcloud. Unlike the development of a standalone application, this project is working within an existing ecosystem. In this guest article, Lara Raffel explains the advantages and challenges this approach brings with it.

Why just a new room instead of a new house?

TicketCheck is aimed primarily at associations, initiatives and other organisations working in the public interest. Many of them already use Nextcloud to organise their work: they manage files, coordinate appointments and work in shared groups.

A standalone helpdesk application would mean an additional platform for these organisations: with its own user accounts, a separate login, yet another file storage system and extra administrative work. Technically, this would of course be feasible. However, any feature that is developed in-house would then also need to be maintained and updated.

So why build a second building when the people we’re developing it for are already working in one?

The decision to integrate TicketCheck directly into Nextcloud was therefore an obvious one. The app extends the existing working environment with a feature that has been missing from the Nextcloud system until now: the structured handling of requests.

When the building already has walls and doors

Developing within an existing platform fundamentally changes what you need to focus on at the start of a project. With a standalone application, many technical foundations must first be laid. How does the login process work? How are users and permissions managed? Where are files stored? What do the navigation and user interface look like?

In Nextcloud, many of these questions have already been answered. The platform comes with user and group management, permission schemes, file storage and notification features. Design fundamentals such as typography, spacing and support for light and dark modes are also in place.

For TicketCheck, this means we don’t have to redevelop these features from scratch. Instead, we can draw on existing structures and focus more closely on the actual requirements of our application.

At first glance, this sounds like a significant time-saver. And in the long term, it certainly is. However, we first need to understand how Nextcloud implements these features and what constraints this places on our app. Some ideas that would make sense for a standalone application become unnecessary as a result. A separate user management system, for example, would not only entail additional development effort but also create a parallel structure that would be separate from the rest of Nextcloud.

The challenge, therefore, is not to develop as many features as possible ourselves, but to make sensible use of the existing capabilities.

Understanding first, developing second

With a standalone application, many architectural decisions can initially be made freely. Within Nextcloud, however, we must first understand which structures and conventions already exist. How are permissions handled? Which interfaces are available? How do our own designs fit into the existing navigation?

This means that, particularly at the beginning, we spend a lot of time understanding the platform, reviewing existing solutions and adapting our concepts accordingly. Not every idea can be implemented exactly as we originally conceived it. Sometimes we have to discard an approach because Nextcloud already provides a better solution. In other cases, we find that an existing feature is not sufficient for our specific use case and we need to make additions.

As a result, getting started can seem more labour-intensive than simply beginning to implement our own solution. In return, however, we avoid parallel structures and unnecessary technical dependencies in the long term. This also has implications for maintenance. We do not need to run our own password management system, maintain a separate file storage system or keep a comprehensive user management system up to date. At the same time, we are, of course, dependent on the further development of the Nextcloud platform and must ensure that TicketCheck remains compatible with future versions.

So the integration does not relieve us of all technical responsibility. It shifts it: away from operating basic infrastructure and towards the meaningful integration of our application into an existing system. This integration is particularly relevant for our target group. Small organisations often have only limited financial and human resources for managing their digital infrastructure. Every additional application potentially means more accounts, extra maintenance and new data protection requirements.

TicketCheck is therefore designed to work within the organisations’ existing environments. The data remains on an organisation’s own Nextcloud instance or one of their choice. User accounts and files are managed within the existing infrastructure. If TicketCheck is no longer required at some point, the app can be deactivated without having to abandon the rest of the working environment. This also supports the organisations’ digital sovereignty. They can determine their own infrastructure and expand it with new functions without having to rely on yet another external service for every additional use case.

At the same time, this approach requires discipline during development. A shortcut that works in the short term but circumvents the platform’s conventions can cause problems later on. Precisely because TicketCheck is part of a larger system, we must respect the existing structures.

Where the actual product development begins

Although Nextcloud provides the technical framework, it does not determine the technical functionality or user experience of TicketCheck. It provides the infrastructure, but it does not know how a helpdesk should function in the day-to-day operations of a public-benefit organisation. That is why in-depth UX research and subject-matter familiarisation were essential for the development of TicketCheck.

This is particularly noticeable when processing tickets. What statuses can a request go through? Can a ticket that has already been processed be reopened? What information do the requesters see, and what is reserved for the internal team? And how do we distinguish between a public reply and an internal note?

At first glance, such questions may seem like minor details. In reality, however, they play a decisive role in determining how intuitive and reliable the application will be later on.

The same applies to the language of the user interface. Whilst Nextcloud offers a translation function, this does not mean that the interface is understandable to everyone. Technical status labels may be unambiguous during development, but they are not necessarily comprehensible to people who process enquiries on a voluntary basis. Avoiding technical jargon and keeping the UX writing concise was therefore a key challenge in the product design.

We also had to take a closer look at the search function. Nextcloud already offers a comprehensive search function that makes content from various areas of the instance findable. However, such a global search is not always helpful for day-to-day work with tickets. Here, users want to search specifically for certain enquiries or filter the ticket overview according to relevant criteria. That is why we have provided a separate, deliberately simple filter and search bar. Not because Nextcloud lacks a search function, but because the existing feature serves a different purpose.

Examples such as these clearly illustrate where the actual development work lies: the platform provides the technical foundations. Building on this, we design the workflows that our target group actually needs.

What we’ve learnt from the development process

Working on TicketCheck has shown us that development within an existing ecosystem isn’t automatically any easier. Above all, it’s different. We save ourselves the trouble of developing many basic functions, but in return we invest more time in understanding the platform and designing the interfaces between the existing infrastructure and our own requirements.

It is crucial to recognise early on which problems have already been solved and which actually pertain to our application. After all, not every function that we could develop ourselves should actually be developed by us.

For other software projects, this leads to a simple question: if the people we are developing for already use a digital working environment, do they really need a new platform? Or are they simply missing another room in the building they already have?

Lara is a UX designer and front-end developer from Lübeck and, together with her colleagues Alexander Mäule and Hauke Klünder, is developing the Nextcloud app TicketCheck as part of Class 02 of Prototype Fund.