• Industry:
Financial Services
• Revenue:
€12 Million
• Employees:
45
• Location:
Austria

• Integration of subsidiary bookkeeping operations into the corporate system
• Automation of the conversion and reporting process

• Analyze the business processes and the local regulation of the subsidiary
• Clarify the relationship between business and IT functions
• Optimize the level of integration between operational and accounting staff and systems
• Prepare business data for the automated conversion into the corporate accounting software

• Fix the distrust of the accounting team, which saw its whole way of working change
• Identify process improvements for time and resource saving; conduct the change
• Reconcile local business specifics with the corporate core framework
• Run the missing preparatory gap analysis between start and target situation
• Past difficulties and postponements caused high opposition to this project; there was a need for a highly diplomatic and competent approach to make the project succeed.

Due to the critical project status and the high opposition amongst staff and managers, it was necessary to get work done at the human level as well as on the technical side, sometimes by analyzing entire Excel sheets with accounting events. Past difficulties led to missing resources, so a global approach as a project manager was needed.
More specifically, I:

• analyzed the project context;
• ran a business and technical gap analysis and identified changes by preserving the existing identity and culture of the subsidiary;
• proposed a new plan to include all the constraints;
• acted as an interface between operational, accounting, and IT functions, at the local and the corporate level, in order to convert the business requirements into technical solutions and the technical feedback into business impacts;
• designed technical solutions for process improvements and validated the development after the programming; and
• developed SQL scripts to prepare the data for the initialization of the new accounting process.

I successfully fulfilled the mission, and the project finally landed a few months later.
As a consequence of my interface role and my comprehensive approach to the issues, some long-time issues were eventually fixed, and the time-to-solution accelerated.
The solutions I designed secured the business processes and the conversion to accounting operations, and made it easier for the users to achieve their tasks.
The initialization scripts I developed contributed massively to an error-free migration to the corporate system.

• Excellent understanding of the business and accounting operations as well as the regulatory framework
• Constant endeavor and exchanges between the stakeholders to make operations, accounting, and IT reach agreements
• Awareness of the cultural and linguistic gaps and an ability to close them
• Fast understanding of the desktop software to propose and design improvements
• Experience with and quick understanding of the financing and accounting business, which brings credibility as an IT person among the business and accounting functions
• Excellent skills in Transact-SQL to quickly develop the migration scripts

• Industry:
Insurance
• Revenue:
€1.5 billion
• Employees:
3,100
• Location:
Worldwide

Design and development of a data-management platform to collect, transform, and distribute data between a large variety of sources and targets.
The marketers use the software to manage insurance products sold on the Internet and to prepare and run campaigns.
The software has to be interfaced to the corporate, subsidiary, and partners’ systems using heterogeneous technologies.

• Create a back end system to faster collect and transform high data volumes from numerous sources
• Distribute the data in a normalized format to different sets of e-commerce and e-marketing platforms
• Deploy the back end from scratch for any subsidiary in less than two months, including local specifics and regulation
• Allow marketers to create brand-new products from scratch without IT support

• Deal with a lot of heterogeneous data sources, most of them being unknown at the beginning of the project
• Propose solutions, despite no clear vision nor requirements from the business team
• Often change the short-term planning to adapt the software to new opportunities or strategies
• Process millions of records in minutes and serve them in seconds
• Imposed teamwork with a third-party IT provider in charge of the front ends
• Work with different database systems

I designed and developed a Java-based back end based upon the Spring framework and using technologies as standardized as possible: JPA, REST, SOAP, among others.
The whole module-oriented platform was a web application running on Tomcat 8 and using MySQL, PostgreSQL, and Oracle DB.

More specifically, I used the following:

• Spring Core for the dependency injection
• Spring Batch for the data stream processing
• Spring Security
• Jersey for the REST implementation
• Hibernate for the low-volume database operations
• A tailor-made JPA-annotation-based module, able to persist thousands of records per second to the database for the high-volume operations
• A tailor-made plugin strategy to easily integrate external modules with a few lines of code
• Vaadin for the administration UI

The system was highly configurable and extensible. Thanks to Maven, each build only contained the required components for the targeted environment.
Finally, I set up the Scrum framework in order to match project management with the speed and flexibility expectations from the business function.

The software overreached the goals and allowed deployments from scratch in hours thanks to continuous delivery. Most of the time was spent on configuring the environment and monitoring. The modular architecture allows new features to be developed, tested, and integrated very fast. New subsidiaries can be operational shortly after their decision to use the software, improving their velocity, time-to-market, and ability for change.
Its performance and reliability and the usage of mature technologies made it cheap to host and maintain. No major bug was detected since operation started.
Furthermore, the detailed monitoring of all the activity on the platform made the investigation of potential issues incredibly fast and made it possible to detect the real cause of the issues in minutes.
Each service of the platform is under constant monitoring to detect anomalies in the usage or execution. The number of calls and the execution time were mainly used to detect inconsistencies in the front ends.

• Short ramp-up to learn about the customer, its business, and its culture
• Usage of agile practices to constantly match the developments to the expectations, even when very volatile
• Good technology stack: robust, flexible, and adapted to the specific requirements
• High software quality improved customer satisfaction and accelerated the development of new features

• Industry:
Financial Services
• Revenue:
€90 Million
• Employees:
400
• Location:
United Kingdom

Refactoring of contract-management software for a financial services firm, a core system that has constantly grown over the past decade and runs critical business operations.

• Run a deep analysis of J2EE software to evaluate the reasons behind its poor performances and high volume of bugs
• Propose a plan to fix the issues

• No automated test at all; no technical documentation; outdated business requirements documentation
• No access to running environments
• No support from the development team and even hostility from leads

I ran two complementary analyses. On one the hand, I used SonarQube to provide impartial measures, and on the other hand, I dove into the code to evaluate the potential design issues.
As a result, I provided an aggregated summary of the issues detected on both evaluations and a detailed plan to refactor the software with clear goals: removing all dead code and most duplicates, lowering the coupling, and increasing the consistency and reusability of the components as well as the overall testability of the software.
The plan described how to refactor the software based upon a domain-driven strategy and gave a clear step-by-step workflow to achieve it. The expected resulting architecture was composed of modules to isolate the responsibilities and force the usage of abstraction. Some technical components had to be replaced by state-of-the-art solutions and libraries.
I also set up automated integration tests to support the refactoring and prevent future potential regressions.

The execution of the plan massively reduced the number of lines of code and drastically improved the overall performances as well as the effectiveness of the developers in fixing bugs. The coverage of unit tests rose from 0% to 65%, during the refactoring period alone.

• Maven and Jenkins for the build and tests automation
• Selenium and JMeter for the integration tests
• SonarQube for the static code analysis

• Long experience in the financial services sector and with similar software to better evaluate the responsibilities and behavior of the software
• Good knowledge of the technical stack and its state-of-the-art status
• Strong determination to succeed

• Industry:
Vehicle Manufacturing
• Revenue:
€5 Million
• Employees:
30
• Location:
Europe

Setup of continuous integration and delivery for software designed to process and render embedded data of connected vehicles.

• Automate the build, qualification, and delivery onto a cloud-hosted machine
• Ability to run several builds per day and deploy a stable version or hotfix in five mouse clicks
• Measure the quality of the software and detect deteriorations and regressions
• Keep the history of all analyses done in the past

• Very low budget
• No dedicated team or human resources
• Different environments and databases supported

I set up a continuous-integration and delivery environment on Jenkins using pipelines.
With a small set of reusable pipelines, different builds for different contexts could run with very low maintenance.
The builds were either manual, scheduled, or kicked off by commits on Git or other builds.
The full deployment process is a configurable build to select the environment and kind of build to deploy.
Jenkins uses a master machine and several lightweight agents in the cloud for scalability and control of costs.
Once a night, a full build with coverage and analysis with SonarQube runs to provide impartial quality statuses.
Tests run to volatile third-parties Docker containers to check all the environments and databases with no need for system administration for each specific one.

More specifically, I used the following:

• Jenkins for the build and tests automation
• SonarQube for the static-code analysis
• Maven to configure the building and testing
• JUnit and Clover for the test coverage
• Cargo plugin for Maven to test the deployment on several systems (Tomcat, Jetty, JBoss)
• Docker to test on different database systems (MySQL, PostgreSQL, Oracle XE)
• Gatling for the integration tests of the API

The maintenance cost was very low. The system only required a few updates to reflect major changes in the software. Thus, the changes in the Jenkins pipeline became part of the development process, which made the programming consistent at any time with building and deploying, whatever the branch.
The monthly invoice for the cloud-hosting was less than €70.
Technical debt was specifically checked to stay below 2%, and critical or major technical issues were fixed before going into production, only a couple of hours after the developers coded the related features.

• Jenkins for the build and tests automation
• SonarQube for the static code analysis
• Maven to configure the building and testing
• JUnit and Clover for the test coverage
• Cargo plugin of Maven to test the deployment on several systems (Tomcat, Jetty, JBoss)
• Docker to test onto different database systems (MySQL, PostgreSQL, Oracle XE)
• Gatling for the integration tests of the API

• Experience with continuous-integration/-delivery patterns and Jenkins in particular:
  • Clear and repeatable workflow
  • Build scripts stored in the code repository, next to the application code
  • Reusable pipeline scripts in Jenkins to decrease the side effects of changes
• Good skills at
  • administrating Linux and Docker and
  • building Docker images for specific needs