What a discovery pilot is for
A legacy code discovery pilot is a small, time-boxed proof on one real piece of your system. It is not a migration and it is not a demo on sample data. The point is to find out, before you commit to a larger program, whether an approach can recover the business meaning in your code well enough for your team to trust it.
Most stalled modernization projects stall at the same place: months spent trying to understand what the existing system does before any new code is written. A pilot tests that step in isolation. If the understanding holds up on a bounded module, you have evidence for the next decision. If it does not, you found out cheaply.
Two weeks is a workable length because it forces a narrow scope. A pilot that tries to cover the whole estate stops being a pilot and becomes a first phase of the project with no clear finish line.
Choose a bounded module
The module you pick decides whether the pilot tells you anything. Look for a subsystem with these traits:
- Real, not toy. It should be code your team actually runs and changes, such as a payment calculation, a policy rating routine, or a set of Oracle Forms screens for one workflow. A cleaned-up sample proves little.
- Bounded. It has clear edges: a known set of programs or forms, a limited number of tables, and a short list of callers. If nobody can say where it ends, narrow it.
- Poorly understood. If your team already knows it by heart, the pilot cannot show new value. Pick something where the original authors have left and the documentation is thin or wrong.
- Representative. It should use the languages and patterns you will face later, whether that is COBOL, PL/I, or Oracle Forms.
Avoid the module everyone is afraid of. A tangled core that touches everything is a poor first test. Start with something one notch easier than your worst case, and plan to scale up if the results are good.
Set the questions the pilot must answer
Write the questions down before the pilot starts. Vague goals like “see how it works” make it impossible to call the pilot a success or a failure. Good pilot questions are concrete and checkable against the code and against the people who know it:
- What business rules does this module enforce, and where in the source does each one live?
- If we change a specific field, which other programs, records, and screens are affected?
- Where does a given value come from, and where does it end up?
- Is there code in this module that nothing calls?
- Can someone who has never seen this module explain what it does after using the output?
Aim for a short list your team can actually review in two weeks. If you have ten questions, you probably have three real ones and seven restatements. For deeper background on the types of questions worth asking, see our guide to change impact analysis for legacy code and the walkthrough of tracing a field from screen to table.
Define what evidence counts as success
Agree on the evidence standard up front, with the people who will have to defend the decision later. Three habits keep a pilot honest:
- Tie every answer to source. A rule that cannot be traced back to the lines of code it came from is a guess. Insist that each finding links to its evidence so a reviewer can open the code and check.
- Use a reviewer who knows the module. If a developer or analyst with real knowledge exists, have them grade a sample of the findings. Count what was right, what was wrong, and what was missing.
- Test a change you already understand. Pick one past or hypothetical change and see whether the impact trace matches what your team knows happened.
Decide the pass bar before you see results. For example, you might require that a named reviewer confirms the business rules for the module and that the impact trace for one chosen field matches their own understanding. Write the bar in plain terms so nobody argues about it afterward. If you want to see how AI reads this kind of code, this plain-language explanation covers what the analysis is actually doing.
Decide what happens next
Settle the follow-up before day one, so the pilot ends in a decision and not a pile of slides. There are usually three outcomes:
- Expand. The evidence held up. Extend to the next module or the wider estate, and use the pilot findings to scope the work.
- Adjust. The approach worked on some questions and not others. Change the scope or the target and run a short second round.
- Stop. The output was not trustworthy enough for your code. That is a legitimate result, and it cost two weeks instead of a full program.
Whatever you choose, keep the findings. Recovered business rules and dependency maps are useful for audit, for knowledge transfer, and for planning, even if the larger project is delayed. If the pilot points toward modernization, the next reading is how to scope a modernization project with less guesswork and the questions to put to any vendor in the vendor evaluation checklist.
Legacy code discovery pilot: common questions
What is a legacy code discovery pilot?
It is a small, time-boxed proof run on one real subsystem of your own code. It tests whether an approach can recover business rules and dependencies well enough for your team to trust it, before you commit to a larger modernization project.
How do I pick the right module for a pilot?
Choose code your team actually runs, with clear edges and thin documentation. It should use the same languages you will face later, such as COBOL, PL/I, or Oracle Forms, and should not be the most tangled part of the system.
What should the pilot answer?
A short list of concrete questions: which business rules the module enforces and where they live in the source, what a field change would affect, where a value comes from, and whether any code is unused.
How do we know the pilot worked?
Agree the evidence standard before starting. Every finding should trace back to source code, and someone who knows the module should check a sample of the results against what they know.
What happens if the pilot does not go well?
Stopping is a valid outcome. You spent a short, bounded effort instead of a full program, and any rules or dependency maps that were recovered are still useful for documentation and audit.