The best software solutions in Switzerland were celebrated at the Zurich Convention Centre on 19 November 2024. Particularly radiant: the start-up Apriko was a double winner with a gold medal in the Business Solutions category and a silver medal in the Cloud Native Solutions category.
Have you ever wondered what payrolling or payroll actually involves? And do you already know Try & Hire? The answer is not so simple because the term “payrolling” is used for 2 different services.
Apriko was developed as a microservice application to meet the increasing requirements of modern enterprise applications. This architecture approach provides the agility, scalability, and maintainability required by today’s software systems. It has proven its worth with major software companies such as LinkedIn, Spotify, and Netflix.
Unlike monolithic architectures that focus on a large, coherent application, a microservice environment consists of many small, independent applications. Each of these microservices fulfils a specific technical task in accordance with the Single Responsibility Principle, manages its data in its own database, and can be developed, tested, and put into production autonomously.
The challenge with such architecture approaches is to actually develop independent applications with their own databases without creating dependencies. For example, it is a real challenge to be able to generate an employment contract in a service without knowing the People service, or calculate wages without having to access the People and HR service.
At Apriko, we use an event bus for communication between the microservices. This allows any application with the appropriate access rights to publish data in the form of messages without knowing the recipients. Other applications can subscribe to certain messages they need without having to know the sender. The received message can then be processed as needed, and the application can store and expand the required data in the desired form.
Applied to the previous example, the People service would publish all new and changed personal data. In this case, subscribers to these messages would be the HR service and PayrollGlossary service. The HR service enriches the data with contractual aspects such as duration, leave, salary, etc. and publishes the contract data, which in turn can be used by the PayrollGlossary service to calculate the salary in combination with the personal data.
Depending on the user guidance, the user creates the contract and the person in one step. How can the dependency be resolved in this case? And what happens if the People service is not available at the time of saving and the person cannot be created? What then is the status of the contract? These examples illustrate the complexity and numerous challenges of such an architecture.
Another challenge in a dispersed microservice architecture is to ensure a complete and consolidated view of the data despite the decentralised data management by different services. Since each service only manages part of the required information, it is not possible for an individual service to perform a comprehensive query of all relevant data. To solve this problem, we have developed a Model service. This service receives and processes messages from the various microservices and uses them to create an aggregated view of the data. The Model service thus functions as the preliminary stage of a data warehouse and enables complex, even graph-based queries of the hierarchically structured data.
Such loosely coupled and carefully developed software offers the following advantages and opportunities:
An API-first approach focuses on the API product and less on the underlying technology. The goal is to develop an API that is both efficient and user-friendly. A well-designed API makes it easier for users to retrieve information and build their own applications based on it, which creates a flexible and versatile ecosystem.
At Apriko, we develop our API according to the Behaviour Driven Development (BDD) approach. The behaviour of the API is defined in automated acceptance tests. API development is test-driven and based on precise specifications that define the behaviour of the software, automated tests, and acceptance criteria. This ensures that all functions and their behaviour can be tested fully automatically. This allows the API to integrate seamlessly with other systems and communicate faultlessly with both external applications and our own user interface.
In order to offer Apriko users a modern, seamless and platform-independent experience, we rely on Progressive Web Apps (PWA). A PWA makes it possible to create web-based applications that behave like native applications and ensure a consistent user experience across different devices. This technology combines the flexibility of web technologies with the ease of use of native apps and provides a highly responsive and engaging user interface.
In combination with our microservice architecture, the use of a PWA allows us to integrate the individual applications flexibly and efficiently without the technical logic being implemented in the PWA itself. Our PWA consumes 100% of our APIs that are developed according to the API-first approach. This means that all functions are fully processed by the APIs and the PWA merely serves as a frontend that processes and displays the data and functions of the API. This clearly separates the user interface from the business logic and enables a clear and maintainable architecture in which changes to the technical logic in the APIs can be made without affecting the user interface.
In our architecture, we rely on a model-driven design, in which our domain model serves as the central basis for development. This approach enables us to generate all code components fully automatically, from the APIs to the database structures and the Progressive Web App (PWA). By using specially developed code generators and algorithms, we can ensure that all components are created consistently and based on the central domain model.
The advantage of this approach lies in its high efficiency and error resistance. Once the domain model is defined, our tools automatically generate the necessary code for the API logic, database schemas, and PWA interface. This significantly reduces manual effort and minimises potential inconsistencies, as all parts of the system are seamlessly coordinated. Developers can therefore focus on the specific requirements and the actual nature of the application instead of dealing with the detailed implementation of the individual components.
This model-driven approach promotes system consistency and maintainability, as well as speeds up the development process. Since most of the code components are created automatically, changes to the domain model can be reflected quickly in all affected areas of the system. This supports agile development in which modifications and enhancements can be implemented quickly without losing track of the complex relationships between the API, database, and user interface.
In summary, Apriko’s combination of model-driven architecture, microservices, and progressive web apps (PWA) creates a particularly powerful and flexible platform for modern enterprise applications. By using a central domain model and fully automated code generators, we optimise the consistency and efficiency of development. This allows our developers to focus on technical aspects and improving the user experience, rather than dealing with redundant implementation work.
Complexity is high in modern software development, especially in microservices architectures. But what do you do to avoid errors in simple and repetitive tasks?
The development of modern software requires agile methods in order to be able to react quickly to market changes and ensure quality at the same time. DevOps offers the ideal solution here thanks to the close integration of development and operation.
A central design principle of Apriko’s software architecture is to automatically generate as much boilerplate code as possible or to derive logic. This allows the development team to focus more on the “what” and less on the “how” (the time-consuming detail work).
At Apriko, we strive for a high degree of automation of customer processes, a fast market launch, and continuous improvement of our software. To ensure this in a demanding domain and complex software architecture, precise planning and consistent implementation from the outset are essential.
As a member of an agile Kanban team, you drive the domain forward and shape the vision, roadmap, and features. You implement features from backend to frontend, actively shape the process, and further develop services, APIs, and engines for backend, API, and web UI generation. You conceptualize and implement software infrastructure requirements with a focus on clean code, good performance, and high test coverage.
Share interesting content and useful information.
