Hackathon Recap: Code, coffee & creativity.

Automatic document reading: from PDF to structured data

Many organisations work daily with documents that need to be processed manually. Think of retyping information from PDF files, contracts, forms or CVs. A time-consuming and error-prone process. So we asked ourselves: couldn't this be done smarter? How do you ensure that documents are read out automatically and that the correct data ends up directly in a structured database or system?

The aim is to extract information from unstructured documents and store it in a predefined data structure. This can range from customer data to product information or work experience, depending on the type of document. A CV is a recognisable example of this: names, work experiences, education and skills can be retrieved automatically and linked directly to the appropriate fields in the system. But the same principle applies to other document types such as invoices, order forms or reports.

A key concern with these types of applications is privacy and data protection. When working with personal or sensitive information, such as that contained in CVs or contracts, it is crucial to ensure proper processing. In this approach, all data is processed within a protected, local environment. It uses a pre-trained AI model that runs entirely locally, without sending data to remote servers or cloud solutions.

This secure and responsible deployment of AI makes it possible to automate document processing, save time and reduce errors, while ensuring the protection of sensitive data.

Using Laravel Filament, they built a proof of concept. The user uploads a PDF, after which AI reads the text and converts it into a structured JSON file that ends up in the database. For this project, we chose to use Ollama, specifically because this solution can be run locally from a proprietary machine. This gives us full control over the environment and allows us to accurately analyse what differences occur between a local installation and using external APIs that facilitate different Large Language Models (LLMs).

By running locally with Ollama, we can, among other things:

• Monitor performance yourself, without relying on external network speeds or API limitations.

• Gain insight into resource utilisation and latency on the machine itself.

• Better test the impact of infrastructure on model speed and output.

• Better test the impact of infrastructure on model speed and output.

At the same time, this approach enables a focused comparison with the use of hosted LLM APIs. This helps to make informed choices: when is running locally desirable or necessary, and when does an API solution offer sufficient speed and scalability?

This trade-off is important in situations where privacy, speed or cost are an issue, and where understanding the technical differences is essential for making the right architecture choices.

AI under human supervision.

What was striking was how surprising the AI-generated results were: sometimes it gave clever additions, sometimes funny misunderstandings. It was clear that AI is a powerful assistant, but must always remain under human supervision. This project is still at the beginning, but already shows how a combination of automation and human control can save time and reduce errors.

Technically, everything went smoothly. The app lets users log in, upload and get immediate feedback. Missing data can be added manually, which are then merged back into the JSON file. This creates the most complete profile possible.

The next steps are to make the process even smoother, provide better feedback and add multiple AI models. There will also be an interface to easily work with prompts and data mapping. For instance, this smart tool will soon be able to link job postings to CVs.

AI as a practical enhancer of what we already do.

Another team instead delved into a broader, strategic question: what does AI actually mean for Cube? During the hackathon, we focused on formulating a clear and practical direction for the deployment of AI within Cube. Instead of seeing AI as a stand-alone product, we chose to position it as a smart enhancer of our existing services. The idea is that AI makes processes smarter, utilises data better and supports employees, without becoming complicated or stand-alone.

Important for us was that AI always stays within the context of the organisation so that it does not become a gimmick, but a scalable, secure and valuable addition. Our focus is on solutions that save time, reduce manual work and improve data quality, while really benefiting employees.

During the hackathon, we fleshed out this proposition, collected practical examples, and looked at how best to integrate AI into our current services. We also discussed the next steps: forming an AI team internally, keeping knowledge up to date, developing examples and cases, and preparing marketing to clearly communicate this course.

In short, for us the hackathon was not an experiment with loose AI tools, but a concrete moment to put in place a realistic and usable strategy with which Cube deploys AI in a smart and practical way for clients and employees.

Understanding emails without the hassle.

The third team tackled a recognisable challenge: how do you ensure that clients can easily understand the status of their sent e-mails without having to log into external platforms each time? For this, they used Postmark, an email service that is reliable in sending and tracking transactional emails. Think of confirmations, notifications or status updates sent from systems. In doing so, Postmark provides detailed information about each e-mail: has it been delivered, opened or perhaps not arrived?

By cleverly using the Postmark API, they have made these e-mail insights directly available within their own applications, without users having to switch to Postmark itself. This makes all relevant email status information visible in one place.

They decided to build the technical setup so that the presentation and service layers are separated. This makes the solution flexibly deployable in different Filament applications, without being stuck with one specific user interface. The result? A handy Filament plugin that is easy to install, just like any other plugin.

The plugin provides users with an overview of all sent emails, including important status information such as bounce notifications, open and click statistics and even a preview of the email itself. This not only makes managing e-mails more transparent, but also a lot easier and more efficient.

What the team mainly takes away from the day is that reading and processing data from the Postmark API is doable, especially if you decouple the data from the presentation. The completed prototype provides a solid foundation for a future version, to which further functionalities can be added. The next step? To further extend and refine the plugin to offer clients even more insight and convenience.

What sticks?

This hackathon was not just about building working prototypes (although of course that is very nice), but mainly about trying, failing, learning and discovering together what is possible. It was about that mix of disciplines within the team, developers, business, marketing, testing all kinds of ideas together. The fun we had, the conversations, the experimentation: that's what made it special.

We not only created cool tools and smart concepts, but also discovered where AI can really make a difference (and where it sometimes still needs a little push). Today's insights and experiences are the starting point for what is to come. Soon we will share more about it in blogs, tech talks and practical cases.