Background
The partner is a logistics operator with an internal platform for managing deliveries, warehouses, and routes. The team is distributed and follows a Scrum methodology. Before our engagement, development was handled entirely in-house. As the business scaled, the need arose to expand into new regions, integrate SLA controls into the existing planning module, and reduce the number of erroneous requests from business users.

Solution
We provided a Java engineer proficient in Spring Boot, PostgreSQL, and Apache Kafka. They integrated seamlessly into the team: quickly got up to speed on the technical context, aligned priorities with the Product Owner, and started delivering changes with no prolonged onboarding delays.

Deliverables
• Routing: The routing model was redesigned to account for delivery time windows, weight, dimensions, and warehouse constraints. Business rules were moved to a dedicated layer, routes are now calculated deterministically, and extension points have been added to support new regions and trip types.
• SLA Control:The planner now explicitly respects target time windows and priorities. If a route violates SLA constraints, the planner suggests alternatives. Deviations are captured both at the service level and in the UI.
• Validation & Business Rules: Server-side validation was added on the backend for addresses, time slots, statuses, and conflicts. The UI now receives clear, actionable error messages. Invalid requests are blocked before trip execution.
• Event Processing & Cargo Tracking: Kafka is now used for buffering and guaranteed processing, with order-based keys and partitioning, retries and backoff, and dedicated DLQ topics. Consumer services were rewritten to be idempotent.
• Core Module & API: Heavy operations were moved to background jobs. Reference and geodata are now cached in Redis. PostgreSQL performance was improved with proper indexes and query optimization. Quotas and rate limiting were added to public API endpoints.
• Engineering Hygiene: Static analysis and parallel checks were added to the CI pipeline. Short ADRs (Architecture Decision Records) were introduced to keep architectural context transparent for the entire team.

Outcome & Impact
The planner now respects SLA by default. Routes are generated predictably, and invalid requests are rejected at the entry point. Deployments are smoother, and the engineering team spends more time moving the product forward rather than fixing the consequences of ad‑hoc changes. Following this engagement, the partner expanded the collaboration and requested an additional Java specialist from ML Web Solutions.

Background
When the client reached out to us, the product was already live in production — a B2B fintech platform that was rapidly gaining users. However, the code remained a legacy of the MVP stage: modules written in a rush, chaotic integrations with external services, and technical debt that weighed heavily on the team. The client's developers were working flat out, while bugs and integration failures had become a normal part of the day.

Solution
We introduced a Middle+ Java Backend engineer who became part of the team from day one. They quickly got up to speed with the architecture and started with the most problematic area — the commission calculation module. The logic there changed constantly, with little to no real architecture in place. The engineer built a testable structure, baked in extensibility for future scenarios, and made the service functional and understandable.

Deliverables

• Commission module redesign: A clean, testable, and extensible architecture was put in place, allowing business logic to change without breaking everything around it.
• API decoupling & optimization: The public API was separated from internal interfaces. Throttling was added for heavy requests, and part of the logic was moved to a dedicated microservice.
• Kafka overhaul: Previously used without a clear system, topics were reorganised, consumer services were rewritten to be idempotent, and DLQ (Dead Letter Queue) topics were added to capture and isolate problematic messages.
• CI/CD improvements: Static code analysis was added. Tests were sped up by running them in parallel. QA and analysts could validate changes faster.

Beyond the code
The engineer didn't just write code — they became embedded in the product life cycle. They investigated production logs without being asked, communicated with the team as an equal, and proposed solutions even when the client was still trying to articulate the problem.

Outcome & Impact
Within a few weeks, the client experienced their first "quiet" sprints — no critical failures, tasks completed on time, and a normal, sustainable pace of work. The team was able to switch from putting out fires to moving the product forward.

Background
The customer's platform (NDA) is a system for managing construction and tourism facilities, significantly simplifying navigation and project management at all stages of development — from an investment project application to its commissioning.
The customer implements large‑scale territorial development programmes and investment‑construction projects across different regions of the country. These projects involved huge volumes of data and documentation: calculations, estimates, architectural plans, and more. Existing tools did not provide holistic or transparent process management.

The main problems:

• Data on facilities and projects were stored separately and quickly became outdated
• No single digital register of investment projects and applications existed
• Approvals and report preparation required significant manual work
• As the number of projects grew, the system became increasingly unmanageable

Our task was to develop a single digital platform that would:

• Consolidate data on projects and facilities
• Provide transparency of statuses and implementation stages
• Simplify interaction between process participants
• Create an architectural foundation for further scaling

Solution
We developed a digital platform for territorial development programme management, combining data on construction sites, projects, investor applications, and related tasks. The solution automates interaction between developers, investors, development institutions, and other participants, creating a unified digital environment for planning and execution.
The project was delivered by a team of 20+ specialists — business analysts, designers, developers, architects, and testers. Over 18 months, we implemented a complete digital twin of the investment cycle for territorial development.

Technical stack & implementation highlights

• File storage: Document and file storage implemented using S3-compatible storage
• Asynchronous processing: As load increased, part of the processes were moved to async mode. Existing inter‑server communication via WebClient was supplemented with RabbitMQ message broker
• External integrations: Some integrations with external systems were implemented using the SOAP protocol
• Investor application workflow: Applications were created via Camunda integration. Users could edit/cancel an application at any stage. All construction participants could review the application and approve or reject it
• Printable documents: Key sections (e.g., project passport) required printable forms. We implemented printing according to required natioanl standards with pre‑filled information from the system using Apache POI and JasperSoft frameworks

Key platform modules

• Construction facility and project management
• Investment project creation and support
• Investor application submission and processing
• Task and event tracking
• Analytics and progress visualisation

Outcome & impact
As a result of the project, the customer received a ready‑to‑use digital platform for managing investment and construction projects.

The platform enabled:

• Consolidation: All facilities and projects in a single digital environment
• Speed: Simplified and accelerated investment application submission
• Control: Activity tracking across regions, deadlines, and statuses
• Automation: Analytical reporting and map‑based visualisation

Background
The client is a product IT company with its own CRM system. A major upgrade was planned: a new subscription management module needed to be built, synchronised with the billing system and the call centre API, while also cleaning up the relationships between clients, tariffs, and internal reference data.
At the start, the task seemed simple: "Draw up diagrams and describe the business processes." But it quickly became clear that no documentation for the existing architecture existed, requirements were being defined on the fly, and business logic was based on assumptions rather than rules.

Solution
A middle+ system analyst from ML Web Solutions joined the client's team.

What was done
Week 1 – Discovery through real users
The analyst spent the first week conducting interviews with internal users: managers, support staff, and engineers. Instead of simply documenting "as is", they asked uncomfortable questions:

• "Why do you do it this way?"
• "What happens if…?"
• "What if a client is on two tariffs at the same time?"

These "what ifs" quickly uncovered contradictions in the system's logic.

Week 2 – Deliverables
After two weeks, the client received not just a set of BPMN diagrams, but:

• A unified glossary of terms that had previously been used inconsistently across teams
• Proposals for reusing logic from existing services
• A REST integration specification for billing, including edge cases
• A roadmap for task decomposition for the development team

Beyond the diagrams
The client specifically noted that the analyst "resolved disputes between business and developers because they understood both sides". There was no need to explain what idempotency is or how webhook request ordering works — the analyst built these considerations into the logic from the start.

Outcome & impact
The project is still ongoing. But even at the preparation stage, it became clear: without this level of systems thinking, the client would have sunk into feature chaos. Instead, they now have a structured architecture and a precise understanding of where the product is heading.