Application Modernization Using Boris Exercise – A Component of the Swift Method
Management Summary
The Boris Exercise is a collaborative system analysis technique used within the Swift Method to support software modernization. It enables teams to visualize service interactions, define logical service boundaries, and map communication flows using graph-based representations. This approach supports the decomposition of monolithic systems, highlights coupling and redundancy, and aligns architecture with domain driven design (DDD) principles. The exercise generates actionable insights documented through the SNAP E format and supports adoption of patterns like CQRS and event driven architecture. It improves cross-functional alignment, accelerates architectural decisions, and reduces modernization risk.
Introduction
The Boris Exercise is a hands-on technique that helps teams to translate domain knowledge into a clear architectural view of system behaviour. It enables architects and developers to collaboratively map out service interactions, define system structure, and visualize how data flows across components. By focusing on how the system should ideally function, Boris supports informed decisions around service decomposition, integration design, and modernization strategy.
Why Boris Exercise?
Modernizing legacy systems is rarely simple. Teams often face challenges like unclear service boundaries, hidden dependencies, and outdated documentation. The Boris Exercise helps tackle these issues directly by offering a structured, visual, and collaborative way to understand how systems behave.
Simplifying Complexity with Boris
Legacy systems often grow without a clear structure. Boris helps teams make sense of this by visually mapping how services interact, where data flows, and who owns what. This makes it easier to spot tight coupling and duplication.
Lowering Modernization Risk
Modernization can go off track when teams do not fully understand the current system. Boris reduces that risk by producing clear and actionable insights captured in the SNAP E format to guide smarter decisions.
When to Use the Boris Exercise?
The Boris Exercise is most effective after Event Storming, when teams already have a shared understanding of business events and domain boundaries. It helps transition from domain discovery to architectural modelling, making it ideal for:
Visualizing Boris in the Swift Method
This layered view shows how the Swift Method progresses through key phases:
How to Perform the Boris Exercise
Preparation
Before starting, it is required to conduct an Event Storming session to uncover key business events and domain boundaries. The Boris session builds on this foundation. Whether using a physical whiteboard or a digital tool like Miro or Lucidchart, teams prepare sticky notes, arrows, SNAP E templates, and a legend to guide the exercise.
Prerequisites for Boris Exercise
At this point, it’s helpful to get clear on what’s needed to run the Boris Exercise and what it’s meant to deliver.
To get started with the Boris Exercise, we need an essential input: a shared understanding of the domain events (usually from Event Storming), domain knowledge from subject matter experts, any existing system documentation, and a visual tool like Miro or Lucidchart. These help to understand how the system works and how different services connect.
Identify Bounded
Contexts Place sticky notes for each service or domain and group related ones to visualize the system. Use blue for services, green for queues or topics, and red for external systems.
Map Communication
Flows Show how services exchange information. Focus on how messages move between them. Use black arrows for direct calls and green arrows for messages sent through events or queues.
Recommended by LinkedIn
Add Integration Points To complete the picture, teams add queues, external systems, and shared services. This step highlights how different parts of the system connect and where dependencies or integration challenges may exist.
Facilitate Discussion
Open discussion is encouraged throughout the session. Simple questions like “What goes in and what comes out?”, “Is this better as a direct call or an event?”, or “Do we need to think about logging or security?” can help uncover important details and lead to clearer decisions.
Insights from the Boris Exercise
After the discussion, the Boris Exercise gives you a clear and easy-to-understand map of your system. It shows the different areas (bounded contexts), how they interact (communication flows), and how they connect to things like queues or external systems (integration points). It also captures important decisions made during the session. This map helps keep everything clear, makes it easier to spot missing parts, and supports better planning for improvements.
Ways to Perform the Boris Exercise
Visualizing Boris Exercise
The Boris Exercise visualizes how services, external systems, and event channels interact within a legacy application. It maps synchronous and asynchronous communication flows using directional arrows and color-coded components.
Sticky notes highlight architectural decisions and areas needing further analysis. This output supports modernization by revealing coupling, integration points, and opportunities for event-driven design.
It enables teams to identify modernization priorities and plan service decomposition effectively. The visual clarity accelerates architectural decision-making and reduces transformation risk.
Business Impact and Use Cases
C&CA Specific Use Cases
Service Decomposition for Legacy Modernization
The Boris Exercise can assist C&CA teams in understanding complex legacy systems by mapping service interactions. This approach supports the structured decomposition of monoliths into microservices, aligned with domain-driven design principles.
Cloud-Native Architecture Planning
The Boris Exercise can support C&CA teams in designing cloud-ready systems by mapping service interactions and identifying where asynchronous or event-driven patterns are suitable.
Integration Mapping for Custom Applications
Teams can better understand how different systems and services connect by mapping the flow of data between them. This makes it easier to design clear and dependable integrations, especially when building or updating custom applications.
References and Important Links
