Optimizing Workflow and Architecture Redesign for Corify GmbH

Client Profile

Corify GmbH is a German startup based in Berlin realizing a digital marketplace for the industrial insurance sector. The company offers an innovative platform for efficient and intelligent risk assessment and management. Their services include AI-based insurance administration to enhance transparency, resource efficiency and decision-making in industrial insurance processes for all partners in this business segment.

Challenges

Initial assessment and domain immersion
When we began our collaboration, a partial, though incomplete, solution was already in place, which had significant developmental potential—a characteristic often seen in startups. The key to starting the collaboration effectively in terms of development was gaining a deep understanding of the complex domain and quickly diving into the technical intricacies of the existing system.

Innovative dynamic risk modeling
The biggest challenge proved to be the dynamic model representing risk objects, fully configurable by a domain expert. This approach to risk modeling in the enterprise insurance sector is unique globally. The model, operated by the domain experts, allows for rapid implementation of changes, which become instantly available in services and the web application. This solution enables a swift adaptation of the model in response to rapidly changing market conditions.

Architectural changes
When we began working on the project, it became evident that the existing system architecture, previously optimized for scalability, needed to be more complex to the current business needs. The highly fragmented structure and excessive service decomposition led to unnecessary complexity and extended the time required to deploy new functionalities. Our team decided to modify the system architecture in response to these challenges. A key step was consolidating some services into larger, more integrated deployment units. This approach simplified system management, significantly reducing the time needed to bring new features to market. As a result, we were able to deliver solutions more quickly, which directly enhanced project efficiency and client satisfaction.

Integration with external systems
Integrating with numerous external partners was a significant challenge parallel to the architectural changes. The dynamic nature of the model required us to adopt a unique approach to managing contracts with external systems. Implementing these integrations demanded precise coordination and flexibility to ensure that all systems worked seamlessly together, regardless of changes made to the model. Our approach focused on creating robust and flexible interfaces that could adapt to evolving market demands while maintaining high operational stability. This enabled our team to effectively manage the complexity of the integrations, contributing significantly to the project's overall success.

Flexibility and agile collaboration
The rapidly changing requirements and the dynamic nature of the startup's operations demanded a high degree of flexibility and an agile approach to project execution. In this context, the startup culture, characterized by speed, openness to change, and a willingness to experiment, played a crucial role in the success of our collaboration. By applying Agile methodologies, we were able to iteratively deliver valuable features while simultaneously responding to the client's evolving needs. Regular meetings, close cooperation with the client, and transparency in processes allowed us to quickly identify and address issues, contributing to the successful completion of the project at the highest level.

What we did

Initial domain analysis and planning
We began our cooperation by thoroughly understanding the domain's specifics and analyzing the existing technological solution. This step was crucial as it allowed us to precisely identify the system's strengths and weaknesses, as well as understand the client's unique requirements. With this knowledge, we were able to develop an optimal plan for the product's further development, considering both current and future business needs.

Team structuring and agile implementation
One of our initial actions was to divide the large team into two parallel Agile teams. This division enabled better focus on priorities and reduced project management complexity, leading to greater efficiency and transparency in task execution. Each team could concentrate on a specific project area, minimizing the risk of chaos and delays.

Microservices architecture enhancement
After conducting a preliminary analysis, we decided to continue developing the existing microservices architecture. While it was modern and flexible, we identified areas that could be improved to better adapt to the client’s dynamically changing needs. As part of the ongoing development, we introduced a series of modifications to optimize performance and simplify the deployment process for new functionalities.

Architectural refactoring and optimization
Upon reaching the first milestone, we proceeded with the previously planned refactoring of the system architecture. These changes aimed to simplify the structure, which allowed for an even faster work pace and better scalability of the solution. This enabled us to shorten the time required to deploy new features, directly enhancing client satisfaction and end-user experience.

Continuous delivery and deployment implementation
Simultaneously with the work on the architecture, we decided to implement a continuous delivery approach to achieve full continuous deployment. To realize this goal, we introduced advanced end-to-end testing, covering all critical paths in the system. These tests ensure that every code change is thoroughly checked for its impact on the entire system, minimizing the risk of errors in production. As a result, the process of deploying new versions became not only faster but also more reliable.

Backend development in Kotlin
We leveraged Kotlin 2.0 to build a robust solution that could effectively adapt to the client’s changing requirements. Concise syntax with reduced boilerplate code led to faster development cycles of new features and reduced number of errors. This, combined with Kotlin’s modern features, including functional programming and coroutines contributed to a shorter time to market, which is an essential factor in the startup environment. To keep our codebase consistent in terms of used language and avoid context switching, we introduced tools like Kotest for effective testing and Konsist for maintaining architectural consistency. We also used Exposed for type-safe database interactions with less boilerplate code.

Results

The system allows for the collection and management of vast amounts of risk data and helps brokers with risk assessment. It automatically collects and updates customer risk data so brokers can focus on risk analysis. It provides a dynamic form for risk assets that can be easily adapted to market needs, together with a public API for 3rd parties to integrate and access the Corify data model easily.