Book a demo
Start for free

A look behind the scenes at the 2023 Servoy Hackathon

8 minutes read

Imagine: You have just 2 days to deliver a software project and you haven’t even started yet. It sounds like every developer’s recurring nightmare. However, for Servoy this is done every year – for fun – at the company’s annual ‘Hackathon’, held in the beautiful Romanian city of Timișoara (where Servoy has a regional office).

The Hackathon is a fantastic opportunity to bring the entire company together - to make connections with their colleagues around the world, and to put each other through their paces.

But what is the Hackathon, and why do it?

The core of the Hackathon is a set of challenges that must be completed within just 2 days. Each challenge is unique, and involves using the Servoy platform to deliver a successful software project. There is a competitive edge to this event, as each team is vying for the winning project – which adds considerable excitement.

Servoy’s Hackathon serves two main purposes. On one hand, it’s a fun team-building experience. It brings people together from all over the world and from different departments too. Everyone – from the Finance Team to Sales and (of course) Developers – is united by their team’s objective. This helps make connections between people, but also their separate roles. Each department gains a deeper understanding of how the platform is used in a practical, ‘high-stakes’ setting and helps everyone align perspectives and goals.

The second objective of the Hackathon is experimentation. With challenges that seem almost impossible to achieve, extreme innovation is a natural consequence. New ideas start to flow, concepts emerge, and testing shows how feasible these might be. The Hackathon inspires people, and sparks new ideas for the future.

This year’s challenges were no exception, as we’ll see.

Pushing the limits of possibility

The three best challenges from this year’s Hackathon stand out for delivering something special. Each challenge pushed everyone to achieve the most with the limited time available, and demonstrated how effectively the Servoy platform can support a wide range of different projects, even under pressure.

Despite the demands of these challenges, each team usually manages to deliver a working project or proof-of-concept. In the first 2 hours, of course, no one knows where to start, and everything only comes together in the last 2 hours – but it does get there, thanks to teamwork, cooperation, and ingenuity.

But of course, there can be only one winner.


Challenge #1: Integrating a workflow engine with Servoy

This first challenge was inspired by one of Servoy’s clients, Globis, who wanted to explore the possibility of integrating a workflow engine with Servoy. By doing this, the company could increase the number of (non-expert) users who can create and manage workflows using Business Process Model and Notation (BPMN), with an easy-to-use interface.

The team tackled this challenge by first selecting an open-source workflow engine to integrate. Like many open-source projects, it was written with Java, which is especially easy to integrate with Servoy (although any language would be possible). Following this, the next stage was to create an interface for the developers, for which a plugin was built. Next, they needed to embed a library and research dependencies.

With just 2 hours left, it looked like a lot was still missing from this project. However, the team pulled out all the stops to reach the finish line with a live demo of the project.

The result? Globis was very impressed with the proof-of-concept, and is very enthusiastic about the possibilities of developing it further.

Challenge #2: Rescue a stranded startup from Python

The next challenge was brought to Servoy by a startup software company with a ‘stranded’ project.

It all started with a great concept (we won’t go into the details), but the development team decided early-on to build it with Python. Not necessarily a mistake, of course – Python has its strengths. However, after getting funding and spending more than 2 years working with multinational development teams, they had achieved only 30% of the required development.

Even worse, they had used 95% of the capital they had raised.

And this wasn’t the only issue – Quality Control was poor throughout the project, there had been a loss of source code, and their cloud was insecure and unstable. This promising startup was in Big Trouble, so they approached us to see if Servoy could help ‘rescue’ their project from certain doom.

With just 2 days and a team of only 6 people, it seemed impossible to achieve what a (much larger) development team couldn’t do in 2 years.

But… could they achieve the impossible?

The team decided to start almost entirely from scratch, and build the UX and some functionality fast using the Servoy platform – with one exception. A key part of the backend was left untouched, because Python is very good when it comes to large data volumes, and it seemed unnecessary to fix it. At the time, anyway.

Each part of the project was built in parallel, to ensure timely delivery. However, when it came to connecting with the Python backend module, it became clear that this one part of the original software didn’t work properly either. With just hours to go, the frustration was audible.

But, all was not lost.

Because the UX requirements were clear from the start and the other elements had already been completed, the team was able to demonstrate a proof-of-concept fully-working UX – exactly the way it should be – in record time. And, because the Servoy platform has cloud security and code-checking built in, the quality of the proof-of-concept was very high.

Within 2 days, the Servoy team had demonstrated they could get the project mostly finished, and with a fraction of the cost or time. If only they had started with Servoy at the beginning!


Challenge #3: Building AI-powered documentation for Servoy platform

Now, this project was all about documentation. Sure, it’s not a ‘sexy’ challenge – documentation is rarely exciting – however, this time it’s quite different.

Servoy wanted to take a fresh approach to its own documentation for the platform; to make it more user-friendly, and clearer how samples can relate to use-cases. To this end, the team was tasked with re-doing the samples to make them easier to understand, and to create a fresh approach to the customer experience.

This team was larger than the others, and had support from junior developers. They started by re-engineering the samples by creating simpler use-cases, starting with 20 to 30 samples.

Despite the extremely short timescale, the team used a Scrum/Agile methodology, with 2-hour sprints that kept everyone focused on achieving incremental success. Step by step, everyone stayed on the right path until the proof-of-concept was complete.

By using simpler use cases, it would be possible to deliver more value by making it easier to understand the applications and how they could combine. However, what made this documentation truly different was the incorporation of an AI-powered chatbot as a crucial part of the user experience.

This served as both a demonstration of how easy it can be to create an AI chatbot within a simple button, and also how the whole documentation experience could be facilitated by AI.

Instead of a tiresome manual trawl through the documentation or search results, a user could ‘chat’ with the documentation itself to find what they need. They just have to ask the AI chatbot how to do something, and it would provide an answer. This kind of ‘generative’ experience really helped to leverage the new samples, by showing how they could be used alone or in combination to achieve specific goals.

The result was a well-rounded, highly innovative proof-of-concept that demonstrated how an AI powered search for software documentation could massively improve the customer experience. To top it off, the concept was shown with a well-designed UX, and shown in action in the context of the larger Servoy website.

building on servoy

Who won the Hackathon?

At the conclusion of the Hackathon, the teams got together to vote on the winner and held an awards ceremony, with a traditional Romanian dinner and wine-tasting to celebrate.

In the end, the winning project was the AI-powered documentation, by popular vote. Although all the projects were impressive in different ways, this one was the most well-rounded and innovative solution to a demanding challenge.

After the winning team all selected their prizes, there was one last prize left over. With unanimous agreement, this was awarded to the most enthusiastic participant in the room, who had kept spirits high throughout – even when things looked the bleakest.

Despite the challenges, this event was immensely fun for the whole company – we can’t wait to do it again next year. Who knows what innovations and ideas might come out of it next time?

Share this article via

The end
Join 30k+ developers that stay on top of the latest low code insights!

customer cases

insights and reports

relevant news