4Axes, the company for which I designed and developed Kalia, acts as a key intermediary between healthcare institutions and mutual insurance companies, particularly for managing hospital coverage. Operators associate coverage requests with responses from mutual insurers, a process facilitated by Kalia, a suite of tools designed to optimize and simplify this complex work.
Kalia was designed to simplify the processing of hospital coverage by making exchanges between healthcare institutions and mutual insurers more fluid. Thanks to its modular architecture, it adapts to the needs of users with varied profiles by integrating modules — real applications — that facilitate their daily work.
Table of Contents
An ingenious software architecture serving healthcare
Kalia is a business application designed to optimize critical processes in the healthcare sector, such as hospital coverage reconciliation or managing follow-ups with mutual insurers. Its technical design was conceived to be robust, flexible and easy to maintain, demonstrating a modern and efficient development approach.
A modular architecture: The “LEGO®” approach
We built Kalia on a principle of strong modularity, based on the Qt framework. Imagine Kalia as a collection of independent modules, each being a DLL file loaded dynamically.
- Autonomy and specialization: Each module manages a specific user functionality (for example, document reconciliation or phone follow-up), ensuring functional clarity and great autonomy.
- Flexibility and scalability: This approach allows adding, modifying or removing functionalities without impacting the rest of the application, making Kalia extremely adaptable to new needs.
Here is a diagram representing Kalia’s modular architecture
Three key libraries: Solid foundations
Kalia relies on three distinct libraries, each with a well-defined role, which guarantees architectural quality.
Core Library: The business core in C++
- This is the application brain, concentrating business logic (definition of “Hospitals”, “Messages”, etc.) and cross-cutting functionalities.
- It manages communications with 4Axes webservices, databases, PDF manipulation, email sending and log management.
- Major asset: Entirely in C++, it is designed to be reusable by other projects and integrates automatic unit tests, reflecting rigorous design.
UI Library: visual identity and QML components
- This library is dedicated to user interface, providing a set of generic QML graphical components and Kalia’s visual identity rules (colors, fonts, spacing).
- Innovation: A “Showcase” was developed, a standalone application allowing visualization and testing of all graphical components outside of Kalia. This ensures visual consistency, accelerates development and facilitates manual testing.
Kalia Library: The strategic application binder
- It ensures overall cohesion, defining rules and providing common services that modules need (module management, user actions, notifications, incidents, configuration).
- Valuable functionalities:
- User action cancellation: A unique mechanism allows users to cancel an action after performing it, considerably improving user experience and reducing errors.
- Advanced notifications: Kalia uses a 3-level criticality notification system (INFO, WARNING, ERROR) with distinct behaviors (floating/fixed) and colors, ensuring the user is always appropriately informed.
- Automated incident management: In case of critical problems (WARNING/ERROR), an email is automatically sent to the technical team with detailed information (workstation info, screenshot, logs), guaranteeing maximum reactivity in case of malfunction.
Inspired by “clean architecture”: A quality guarantee
Kalia’s architecture is inspired by Clean Architecture principles, a software design philosophy aimed at creating modular, maintainable and scalable systems. Although adapted to our specific needs, we integrated its key principles:
- Separation of concerns: Each part of the code has a unique role (business logic, UI, data access), facilitating understanding and modification.
- Dependency inversion: Central elements are independent of technical details, making the system more flexible.
- Layered structure: Code is organized in logical layers, each layer depending only on lower layers.
Our pragmatic approach: We adapted Clean Architecture to create an architecture that combines robustness and agility. For example, we introduced the notion of “Models” for display needs (QML) without polluting business “Entities”, and “Handlers” that encapsulate large functional parts. A “Coordinator” was also implemented to manage communication between “Handlers”, thus reinforcing module autonomy.
This architecture, thoughtfully designed and rigorously implemented, reflects our commitment to software quality and ease of evolution, major assets for Kalia’s sustainability and success.
Image gallery
