Modern software like blink.it is primarily one thing for you as a user: Simple. Easy to use. Easy to understand. However, behind “Software as a service” lies a lot of conceptual work. Product Owner David provides insight into the development of the learning platform blink.it - balancing customer wishes, prioritization, and vision.

About the person: David has been the Product Owner for the blink.it learning app since 2021. He is responsible for communication between management, the development team, and customers. His goal: To bring together all wishes and demands in order to create the best possible blink.it for everyone!

Software is not just software. What are the biggest features of a “Software as a service” concept like blink.it compared to classic software?

Traditionally, software was released on CD or DVD. And the version that was on it had to be the right one. Nowadays, this has softened a bit, updates are possible. But what the customer installs on their PC is initially the final version of a software, which the customer pays for once.

On the other hand, software as a service is continuously developed in small steps and constantly improved. And unlike CD software, the customer does not install software, but a browser, and uses the software on the provider's server. The software is available as an internet service for a rental fee.

| Classic Software | Software-as-a-Service, e.g., blink.it || ----------------------------------- | ----------------------------------------------------------- || software is installed | a browser is installed || software available on the computer | software available via browser on the provider's server || a relatively fixed version | is continuously developed || one-time payment upon purchase | monthly or yearly fee |

What are the biggest challenges for you as a Product Owner in the development of blink.it as Software-as-a-Service?

The first challenge arises from the uniqueness: The software must run on all possible browsers. These browsers are constantly being developed, so the software must also be adjusted continuously to ensure everything works. The same goes for the services running on the server. Everything is constantly developed by many parties. This requires continuous development to remain compatible. But this is mainly a challenge for the development team.

The second challenge and actually the first and biggest in my role is the product vision. What do we actually want to achieve with the software blink.it? For example, a vision could be “We want to make effective learning as easy as possible” or “The tool that connects online and face-to-face teaching in the simplest way for all parties.” – The vision can also evolve over time and with customer demands.

The third challenge in the role as PO is the constant decision making and prioritization: When should what be developed? And what impacts will that have elsewhere? So many ideas and wishes come in, both internally and from customers themselves. The decision FOR a development option is always also the decision AGAINST many others. The options are virtually endless. Each decision affects different people in very different ways.

How do you select the features that actually make it into the software?

This is where the vision meets prioritization: Of the many options available – which one contributes the most to helping as many users reach this goal now and in the future? Additionally, a classic benefit-cost analysis is performed. Ideally, we want to take steps that provide the greatest benefit with the least effort.

The decision is never “yes” or “no”, but essentially “now” or “not now”. Just because a customer’s feature request is not being implemented now doesn’t mean it will never be done. Perhaps just later. It can remain in the backlog, in our large collection of ideas.

At the same time, it can also mean that an idea waits while new ideas keep being prioritized - “not now” can also mean forever. This is not always easy to manage and often even more difficult to communicate. The goal here is to always do the most sensible thing now. Then we have made the best of the opportunities.

This is how the selection of development options for the blink.it learning platform proceeds. / Own representation

Some things are so essential for future developments that we must do them, even if they may not bring anything new right now. For example, the new design for blink.it that we are currently developing: It initially brings hardly any new features for the customers. But with the new design, we are restructuring the entire infrastructure underneath, which customers do not see at all. And we need this new structure for the many new functions in the future, and to be adaptable and evolve with our vision!

Many requests from customers continuously come to blink.it, and they also ask why implementation takes so long. What is the reason?

Our customers come up with great suggestions and wishes that I find really valuable! I would love to implement many of them right away. However, if we implemented them NOW, they would be in the old infrastructure and the old design. This would block the development into the future again.

So we unfortunately have to put many of these requests on hold for now - as mentioned, they are not lost. And we are first building the new foundation. THEN we can implement the requests directly with the new technology. This also saves a lot of additional work, developing everything and then having to adjust it completely again for the new design.

"We are always looking for the “sweet spot” between effort, benefit, and vision."

And even then, prioritization will again be based on benefit and effort. As mentioned, these are decisions in a complex environment. And the goal is always to find the ideal balance, the “sweet spot” between effort, benefit for the customers, and product vision.

You say SaaS is developed in many small steps. So how does such a “small step” work at blink.it, and what makes it so complex?

First, we determine the specific goal that our users can achieve with each idea. This requires a lot of empathy. Together with the designers and developers, I need to understand and articulate exactly what the user wants to achieve. It is important to immerse ourselves in our customers and their daily lives with the software. Some of this we can clarify from our end, and often we learn about it through follow-up questions.

With this goal in mind, we try to assess the benefit it brings and what resources we need for it. We then try to assess the complexity together. We compare different development options. Prioritization is ultimately based on the benefit and the necessary resources. We then have an order in which we want to work through the ideas.

"SaaS development is the connection of empathy for customers and technical know-how."

Finally, we discuss how many of those we can tackle in the next two weeks. A development interval, a “sprint”, lasts two weeks for us.

With this goal formulation, we move into the technical implementation. Developers and designers collaborate on this. What is completed is then extensively tested: Does everything work in practice? Once that is ensured, the idea can be released as a finished feature for the customers.

Every new idea goes through several process steps before it is released. / Own representation.

In some cases, like with the new design, the changes are not published directly. Instead, the results from many “sprints” are bundled and then made available to the customers in one go on a specific day. This then looks like we haven't done anything for a long time to the customers. It is, of course, different:

We are ALWAYS working on the platform. This bundling happens when many small things together deliver a rounded result for the customers. For example, publishing a table in just one area of the platform could confuse users. Changing tables in multiple areas simultaneously can be more sensible.

"For the customers, everything looks incredibly easy and smooth. But the reality of software development is complex!"

Software is more than just writing and publishing code. In addition to the software code for different components, the necessary infrastructure is also operated. For example, the mechanisms that automatically start and stop the servers depending on the current user load, allowing for many simultaneous accesses. Ideally, the users see none of this! Users should have an uninterrupted flow in their work without dealing with the complexity. No matter what happens in the background - it should be a simple experience.

That is the paradox of the matter: If we do it right, it looks incredibly easy and very fast for the customers. Understandably, this creates the impression that there is nothing to it. However, the underlying reasons are often more complex than what is visible on the surface.

Test blink.it

Your Admin Demo

From theory to practice: Test the result of the learning platform development yourself! Get to know blink.it in a demo course from a participant's perspective, and then create your own test course.

Request a free admin demo now

Do you have questions about blink.it or this article?

Feel free to write to us if you have questions about the product or specifically about this article. Our marketing team is available to you via email or will refer your request to a suitable Blinkie 😊