WeXL Forge · Modernise · Blueprint

Forge Seams

Proposes strangler-fig seams with an effort estimate per seam

Takes
Dependency graph and business rules from Forge LensLegacy source code, if no map exists yetConstraints: release windows, team ownership, systems that cannot change
Gives
Candidate seams with their interfacesShared data, dependencies and risks per seamAn effort estimate per seam, with its assumptionsA suggested order of work
Updated
Draft

The problem

Once a team decides not to rewrite a legacy system in one go, the next question is where to cut. The strangler-fig approach moves one part at a time behind a stable interface while the rest of the old system keeps running. It works when the parts are well chosen. Pick a seam that shares tables, global state or a batch job with half the system, and the “small” first migration drags on and the whole plan loses credibility.

Today the choice is usually made by a senior architect in a few workshops, from diagrams that are years out of date and from memory. The result depends on who is in the room. The estimates that go with it are often made top-down, and they quietly become the commercial plan.

Good looks like this: seams drawn from the code as it actually is, each with a clear interface; the shared data and hidden dependencies listed for each seam, not discovered mid-flight; an effort estimate whose assumptions are written down so anyone can challenge them; and an order of work that delivers something useful early.

How it works

Forge Seams is built on demand in your engagement. We run legacy modernisation in four steps: map the code, specify it, cut seams, then rebuild one seam at a time. Forge Seams does the third step.

It reads the dependency graph and business rules that Forge Lens produces: modules, calls, shared tables, files, batch jobs and screens. It also takes the constraints only people know, such as release windows, which team owns what, systems that cannot change, and the parts the business wants moved first.

It proposes candidate seams by looking for groups of code that call each other often, call the rest of the system rarely, and own their data. For each seam it describes the interface the new code would sit behind, the tables it shares and how to handle them (move, sync or leave in place), the other seams it depends on, and the risks.

It then estimates effort per seam from things that can be counted: modules and lines, screens, external interfaces, business rules to carry over, and the parity cases needed to prove the move. Each estimate lists its assumptions.

Then it is checked. Every claim about a dependency has to point to the place in the graph it came from, so the architect can follow it. The architect and tech leads review the seams in a workshop, move boundaries and change estimates. The agreed seams become the backlog for the rebuild.

Where it gets it wrong

  • It only sees what the map contains. Dependencies through a shared file drop, a database trigger or a scheduled job that lives outside the codebase may be missing. It flags tables and files with writers it cannot identify, and the workshop asks the people who run the system.
  • Clean in the graph is not clean in the business. A seam that looks tidy in the code may cut across a process the business sees as one thing. The business owner has the final say on boundaries.
  • Estimates inherit the blind spots of counting. Counting screens and rules misses code that is small but hard. The estimates are a starting point for the engineers, and they are checked against actual effort once the first seams are done.
  • It can split too eagerly. Too many small seams add interface and data-sync work. The architect merges seams where the extra boundary costs more than it saves.

Why not just prompt a chatbot

A chatbot can explain the strangler-fig pattern and suggest service boundaries from a description of your system. It cannot see your system. Forge Seams works from a dependency map of the actual code, ties every claim to a place in that map, writes its estimating assumptions down, and leaves the decision to your architects. The map, the evidence behind each claim and the review are the work.

What you get

  • In your engagement: Forge Seams drafts the seam plan during the assessment, and your architects and ours turn it into the agreed backlog.
  • Under your brand: services firms can use it in their own modernisation assessments, with their own estimating model in its rules.
  • Built to own: we build it around your estimating model and hand over the source.

See three ways to use an agent.

Run it on your input.

Send us a real legacy codebase or dependency map. We run Forge Seams on it and send the output back within one working day, with a note on what we would change for your setup.

Start here

See Forge on your own codebase.

Start a conversationWe'll show the Live agents on a real workflow of yours.