Blog

CBA staff leasing: Fairness for temporary workers and security for staff leasing agencies

Read more
Engineering

Behavior Driven Development

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.

Read more

Apriko - a powerful and flexible platform for modern enterprise applications

Engineering
August 12, 2024

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.

Challenges in developing microservices

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.

Communication between microservices: The event bus

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.

Microservice integration challenges

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.

Benefits of a microservice architecture

Such loosely coupled and carefully developed software offers the following advantages and opportunities:

  • Autonomy: Microservices work independently of each other. This refers to both the runtime and the development and deployment. Each microservice can be developed and rolled out independently. They are also technologically independent of each other.
  • Decoupling: Microservices are strongly decoupled from each other. They only communicate via clearly defined and language-independent interfaces. Decoupling takes place at all levels (data management, security, technology, architecture, deployment, etc.). Modules can be easily exchanged and replaced thanks to this decoupling.
  • Automation: Microservices enable a high level of automation for deployments, testing, provisioning, and scaling. In connection with continuous delivery, releases can be independently and quickly put into production thanks to a microservice architecture. With minimal time-to-market, it is possible to react quickly to changes and trends.
  • Scalability: Microservices are built to scale a system quickly and easily. The decoupling allows the modules to be rolled out independently of each other.
  • Resilience: In the event of partial failures and errors, the system continues to function.
  • Security: The encapsulation makes it easier to protect the individual modules. Isolated microservices can be secured separately with firewalls and gateways.
  • Business value: Greater efficiency in development and operational cost savings and increased stability contribute to an improved customer experience and fewer downtimes. The system grows and shrinks dynamically with customer demand, new features are on the market in the shortest possible time, and improved testability reduces the risk of releases.

API-first approach: efficient and user-friendly

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.

Progressive Web Apps (PWA)

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.

Model-driven architecture: High efficiency, consistency, and error resistance

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.

Conclusion: A powerful and flexible platform

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.

Curious? Then get in touch with us!

Thaya Selvarajah
Product owner & Solution Architect

More good reasons for Apriko

Engineering

DevOps at Apriko

August 12, 2024

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.

Job

Full Stack Engineer

April 10, 2024

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.

Engineering

Automatic generation of the graphic user interface (UI)

August 12, 2024

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).

Engineering

Behavior Driven Development

August 12, 2024

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.

Engineering

Reach your target faster and better: With automated code generation

August 12, 2024

Complexity is high in modern software development, especially in microservices architectures. But what do you do to avoid errors in simple and repetitive tasks?

Duration: 9 Minutes
Author: Thaya Selvarajah

This website uses cookies to analyze usage for improvements. You can disable cookies in your browser settings, but doing so may affect website functionality.

Share Options

Share interesting content and useful information.