Use cases
Modernize legacy software with an AI SDLC
Not a big-bang rewrite. An AI software development lifecycle wrapped around the system you already run — modernizing it slice by governed slice.
Legacy modernization with an AI SDLC means wrapping an existing system in AI-assisted engineering instead of attempting a risky rewrite. Ciao's custom sandbox images wrap Rails, Java, Go, Python, Node and multi-process backends, so changes run through governed branches with human approvals, automated QA, live security testing and an append-only audit trail. Unlike big-bang rewrites, modernization proceeds in slices, and the result deploys to your own cloud, private VPC or on-prem under separate terms.
Published 2026-07-03 · Last updated 2026-07-03
Why legacy systems stay legacy
Every organization has one: the system that runs something essential, written by people who have since left, in a stack nobody enjoys touching. Changes take months because nobody is sure what breaks. The backlog of requests against it grows while the will to touch it shrinks. And the standard prescription — a full rewrite — has a failure pattern everyone in the room has lived through: two years, budget doubled, old system still running.
The alternative to a big-bang rewrite is an honest one: keep the system, change how change happens to it. That is what an AI software development lifecycle around legacy software means — the existing codebase keeps running while AI-assisted engineering, wrapped in governance, takes over the delivery of changes, new interfaces and extracted modules, one bounded slice at a time.
Ciao makes this concrete through custom sandbox images that wrap AI-assisted engineering around Rails, Java, Go, Python, Node and multi-process backends — the stacks legacy systems are actually written in. Guardrails maps the code into business areas so the genuinely dangerous zones are visible and protected. Every change moves through governed branches with recorded human approvals, QA and live security testing. And the result deploys where legacy systems live: your own cloud account, private VPC or on-prem under separate terms.
What modernization actually requires
Teams that have survived a modernization program converge on the same requirements:
- Support for the real stack — The system is Rails, Java, Go, Python, Node or a multi-process backend — not a greenfield template. Custom sandbox images wrap the stack as it is.
- A map of what is dangerous — Guardrails maps code into business areas, so payout logic, pricing and compliance-critical zones are identified and protected before anyone changes them.
- Human approvals on every serious change — Governed branches where risky changes are detected, plain-English policies applied, and human review recorded — no silent merges into a system nobody fully remembers.
- Evidence for the change board — An append-only audit trail across prompts, merges, deploys and admin actions — the record change-control processes demand.
- Incremental delivery — Branch-native git, checkpoints and rollback, so each slice ships alone and reverses alone. No moment where everything cuts over at once.
- Deployment into your world — Legacy systems live behind firewalls. Deploy to your own AWS, Azure or GCP account, private VPC or on-prem under separate terms.
How a modernization program runs on Ciao
1. Pick the first slice
A bounded, valuable piece — a reporting layer, one admin console, one module. Small enough to ship, real enough to prove the model.
2. Wrap the stack in a custom sandbox
A custom sandbox image wraps your Rails, Java, Go, Python, Node or multi-process backend, so AI-assisted engineering operates on the real system, not a toy copy.
3. Map the business areas
Guardrails maps the code into business areas and surfaces the protected zones — the parts where a wrong change costs real money.
4. Set the policies in plain English
For example: any change touching payment calculation requires human review. Policies are readable by the people they protect.
5. Deliver on governed branches
Changes are proposed, built and tested on branches; risky ones are flagged; human approval is recorded before anything merges.
6. Gate with QA and security
Deterministic browser replays and smoke gates catch regressions; security scanning with live-confirmed vulnerabilities catches what static rules miss.
7. Deploy inside your boundary, then repeat
Each slice ships to your own cloud, VPC or on-prem environment under separate terms — and the next slice starts with everything learned from the last.
Governance checklist for legacy change
- ✓ Custom sandbox image wrapping the actual production stack
- ✓ Business areas mapped and protected zones identified by Guardrails
- ✓ Plain-English policies on payout, pricing and compliance-critical logic
- ✓ Recorded human approval on every risky change before merge
- ✓ Append-only audit trail satisfying change-control requirements
- ✓ Rollback and checkpoints so every slice is independently reversible
- ✓ Customer code never used for training; zero-retention model contracts
Modernization slices teams ship
Reporting layer over legacy data
Modern dashboards and reporting against the legacy database — high value, low risk, and often the slice that wins the program its mandate.
Admin console replacement
The internal screens users hate most, rebuilt as a modern interface over the existing backend before anything deeper moves.
Module extraction into a service
One well-bounded capability carved out behind an API, shrinking the legacy core a slice at a time.
API layer over a legacy core
A clean, documented interface wrapped around the old system, so new applications integrate without touching its internals.
Screen-by-screen UI refresh
Modern React interfaces replacing legacy screens one flow at a time, with QA replays proving parity as each one ships.
Workflow apps beside the system of record
New approval and intake workflows built alongside the legacy system, feeding it clean data instead of modifying it.
Rewrite risks and how the AI SDLC answers them
| Rewrite risk | AI SDLC approach on Ciao |
|---|---|
| Big-bang cutover fails | Slice-by-slice delivery; each piece ships and reverses independently |
| Nobody knows what is dangerous | Guardrails maps business areas and protects the critical zones |
| Unreviewed changes to critical logic | Governed branches with recorded human approvals |
| Stack does not fit modern tooling | Custom sandboxes wrap Rails, Java, Go, Python, Node, multi-process |
| Regressions surface in production | QA replays and smoke gates before publish; checks after |
| Change board has no evidence | Append-only audit trail across the entire lifecycle |
| Code cannot leave the building | Deploys to your cloud, private VPC or on-prem under separate terms |
Frequently asked questions
Does Ciao only build new React apps, or can it work on our existing stack?
Both. Greenfield builds generate React, TypeScript and Supabase applications, and custom sandbox images wrap AI-assisted engineering around Rails, Java, Go, Python, Node and multi-process backends — which is what a modernization program actually needs.
How do we keep control over changes to a system nobody fully understands?
Guardrails maps the code into business areas, detects risky changes, applies plain-English policies and requires recorded human review before merge. The people who understand the business approve the changes; the audit trail proves they did.
Why is slice-by-slice better than a proper rewrite?
Because each slice ships value, carries its own rollback and teaches you about the system before the next slice starts. A rewrite defers all value and all learning to a single cutover — the pattern behind most failed modernization programs.
Can this run inside our network?
Yes. Deployment targets include your own AWS, Azure or GCP account, private VPC and on-prem, under separate terms. Modernization programs for regulated systems typically run inside the customer's boundary — talk to sales about the terms.
Is our source code used to train models?
No. Customer code is never used to train models, and inference runs under zero-retention model contracts. SOC 2 Type II reports are available under NDA for your security review.
How do modernization engagements start commercially?
As a scoped first slice inside a development program — programs start at USD 10,000 per year. Bring the system you are most afraid of to a sales conversation and the first slice usually identifies itself.