In short
- Keep developing the existing system when it works, has a sensible architecture and the problem is individual modules or missing tests.
- A rewrite makes sense when the technology is unsupported, changes cannot be made safely and the cost of each change keeps growing.
- The safest route is piece-by-piece replacement: new modules are built next to the old system and take over functions one by one, while the old system keeps running.
- The decision should follow a code and architecture review - usually a few days of work, billed separately.
- Rewriting a mid-sized company system usually costs PLN 120,000-300,000 or more (about EUR 28,000-70,000+); that is why it pays to start with the module that hurts most.
Signs that something has to be done
- Simple changes take weeks because nobody knows what else they will break.
- Old bugs return after every release, and there are no automated tests.
- The technology, libraries or server no longer get security fixes.
- It is hard to find people who know the system's technology.
- The system cannot connect to new tools (API, mobile app, customer portal).
- Performance drops as data grows, and adding servers no longer helps.
Develop, rewrite or replace piece by piece
| Keep developing | Rewrite from scratch | Replace piece by piece | |
|---|---|---|---|
| When | Sensible architecture, local problems | Unsupported technology, changes impossible | A large system that cannot be stopped |
| Cost to start | Lowest | Highest (the whole system at once) | Spread over stages |
| Risk | Technical debt keeps growing unless it is paid down | Nothing new for users for a long time, risk of missed features | Lowest - each stage works before the next |
| Effect for users | Immediate | Only after the switch | After every stage |
What piece-by-piece replacement looks like
- We pick the module that hurts most or changes most often.
- We build it anew next to the old system, with access to the same data or with sync.
- We move users to the new module and switch the old part off.
- We repeat for further modules until the old system is no longer needed - or only what works well stays in it.
This approach costs about as much as a full rewrite, but the money is spent in stages and every stage delivers an effect. You can also stop at any point without losing what was built.
Where to start: a code and architecture review
Before deciding, commission a review: code structure, dependencies and their versions, tests, deployment, security, performance and documentation. The result is a prioritised list of risks and a recommendation: what to develop, what to replace and in what order. Without it, a decision to rewrite is often based on frustration rather than facts.
How 2Simple helps
2Simple takes over development of existing systems, including from other vendors. We start with a code and architecture review, show the risks and a plan, then take over development gradually without stopping the product. When replacement makes sense, we do it piece by piece, in TypeScript, React, Node.js or Rust.