Software Modernization
We modernise software for companies using old desktop applications, mainframes or ageing web systems: module by module, with system analysis, data migration and rollback planning, moving to the cloud where appropriate.
Who it is for
Software modernisation aims to preserve business rules and data while renewing legacy software. A rewrite is not always necessary: improving the existing system, connecting it to a new interface through an API or replacing selected modules may be sufficient. Dependencies determine the parallel-running period, maintenance window and acceptable downtime.
When is it needed?
- IT: only one or two people still understand the system; even small changes take weeks.
- Business teams: there is no API for a new portal or bank connection; data moves through overnight file transfers.
- Security: the operating system, database or language version is no longer supported and receives no patches.
- Management: maintenance fees rise each year, and the system shuts down for a weekend with every release.
When is it unnecessary?
- If the system is supported and only the screens are outdated, refreshing the interface or adding an API layer may be enough.
- For standard processes such as accounting and payroll, a current off-the-shelf package is often more economical.
- If there is no legacy system and the process runs in Excel, you need custom software development.
Choosing an approach
Keeping, gradually modernising and fully replacing a system are separate decisions. Before its age, assess support status, business rules, data access and the need for change.
| Option | When is it suitable? | What should be verified first? |
|---|---|---|
| Keep and improve | The core works and is supported; the problem concerns a specific screen, report or connection. | Support and security status, access to make changes, and whether a focused improvement resolves the actual problem. |
| Modernise gradually | The system supports the business, but some modules need changing and functions can be separated. | Dependencies of the first module, data ownership, the cost of parallel running and a rehearsed rollback boundary. |
| Replace completely | Maintaining the existing core is no longer appropriate; business rules are documented and the target solution is validated. | Whether the package or new software supports critical flows; data migration, archive access, training and transition acceptance. |
Example decision: if only the ordering screen of a current ERP is inadequate, keeping the core and adding a custom portal may be appropriate. If the ordering module can be renewed independently, consider a phased transition. Full replacement may suit a small legacy application whose complete workflows have been verified in a ready-made package. These are examples; even choosing full replacement does not mean an overnight transition without downtime.
Scope
We agree the scope during discovery. The example below is a typical first stage moving one legacy module to a new platform; later modules follow the same path.
Discovery and risk map
Modules, dependencies, overnight jobs and data; each module's risks and business owner.
Business rules catalogue
Rules extracted from code and experts are documented in a readable list and protected by tests.
Routing layer
Sits in front of the legacy system, moving traffic to the new platform module by module.
Data sync and migration
Event-based bridge or change data capture (CDC), trial migration and reconciliation.
First module
The selected module's new backend and user interfaces.
Infrastructure and release pipeline
In the cloud or on your server, with controlled releases, data reconciliation and a rehearsed rollback plan.
Outside this example's scope
- Migrating every module in the first stage
- Refactoring the legacy system's code
- Licence and cloud fees (charged directly to your accounts)
Assumptions
- Read access to the legacy database and a test copy are available.
- Someone who knows the system contributes a few hours each week.
- The first stage covers one module end to end, such as order entry.
- Open records are migrated; older records remain readable in the archive.
Step-by-step method: Guide to transitioning without stopping the legacy system
Example scenarios
Explore the use cases
Each scenario starts with a modernisation decision; we define yours together during discovery.
-
Choosing the first module
- Role
- IT manager and process owners
- Input
- Module list, usage frequency and dependencies
- Action
- Compare modules by value, dependencies and risk; prioritise a frequently used module with few dependencies.
- Output
- Risk map, first-stage scope and stage sequence
-
Parallel running
- Role
- Process specialist
- Input
- Real operations and the results from both systems
- Action
- Compare reads or operations with isolated side effects across both systems; do not create payments, notifications or records twice.
- Output
- Discrepancy report, rules added to the catalogue and transition decision
-
Data migration rehearsal
- Role
- Data controller
- Input
- Legacy database, field-mapping table and cleaning rules
- Action
- Migrate data into the test environment, compare counts and amounts, and rehearse rollback.
- Output
- Reconciliation report, records to correct and an approved transition plan
Example screens
Product concept: a solution study through interface designs, not an interactive demo or customer project. X Sigorta is fictional; the screen data and migration plan are illustrative. All product concepts
Integrations
Integration details
The most critical connection is the bridge between the legacy system and new platform. During discovery, we document each flow's direction, frequency and source of truth.
| System | Examples | Transferred data | Direction and frequency |
|---|---|---|---|
| Legacy database | SQL Server, Oracle, DB2 | Changed records and master data | From old to new; any necessary reverse transfer is designed separately |
| Mainframe and AS/400 | IBM z/OS, IBM i (AS/400) | Batch-job outputs (COBOL, RPG) | During a scheduled window, through files or a queue |
| Desktop application | Delphi, VB6, WinForms | Transactions in a shared database | Old and new screens see the same record |
| ERP and accounting | Logo, Netsis, Mikro, SAP | Accounts, stock and invoices | New module connects through an API; the old connection remains |
| Identity and access | Active Directory, LDAP | Users, roles and permissions | Single sign-on (SSO), same identity |
If the bridge fails
The transfer queue, duplicate prevention and bounded retries are designed together. A migration rehearsal compares not only record counts but also amounts by customer and period, statuses and relationships. Responsibility for unexplained differences and criteria for stopping the transition are clear. Records created in the new system must be reconciled before rolling back; rollback involves more than reopening the old screen.
Transition plan: data migration rehearsal, reconciliation and rollback. For connection methods, see the ERP integration guide.
Product names are examples and do not imply a partnership.
Process
Steps in our process
-
01
Discovery
We inspect the code, database and workflows, map risks and recommend the first module.
1–2 weeks -
02
Definition & Prototype
New screens are tested with real users in week 3; the migration plan is documented.
2–3 weeks -
03
Build
Weekly working-software demos, parallel running and gradual transition.
Two-week sprints,
first-stage target: weeks 6–12 -
04
Grow & Operate
Subsequent modules are migrated; the replaced legacy module is retired.
Ongoing
This is an illustrative schedule assessed once access and pilot scope are clear; the final duration is determined during discovery. Step-by-step details: how we work
Budget and timeline
We do not publish a price list; system size and data condition determine cost. After discovery, you receive a written proposal and roadmap.
- Number of modules
- Modules to migrate and their dependencies.
- Data volume and quality
- Record counts, historical years and cleaning.
- Undocumented rules
- The amount of business logic to extract from code.
- Integrations
- Connected systems and file transfers.
- Parallel running
- How long both systems will run together.
- Target infrastructure
- Cloud or server; compliance requirements.
- Discovery sprint
- 2 weeks Fixed scope, fixed fee
- First stage
- 6–12 weeks A first module scoped together, rather than the entire programme
- Later stages
- In the roadmap Each stage goes live independently
Delivery terms
Delivery and maintenance details
Knowledge no longer depends on one or two people: you hold the code, rules and migration records.
Code and intellectual property
Transfer of project-specific code and designs, third-party licences and usage rights are defined separately in the contract.
Accounts
Repository, cloud and monitoring accounts are registered to you from the outset.
Business rules catalogue
Each rule is documented clearly with its source, owner and test.
Migration records
Mapping tables, migration scripts, reconciliation reports and rollback plan.
Tests
Catalogued rules are protected by automated tests; untested releases do not go live.
Handover and support
Handover through joint sessions; maintenance, support hours and response targets are agreed separately.
Frequently asked questions
Wouldn't a rewrite from scratch be faster?
It may look shorter on a schedule, but concentrates all risk into a single transition day: the old system is frozen while the new one is prepared, and undocumented rules emerge only in production. A one-time transition may make sense for a small system with documented rules; we assess the right approach together during discovery.
Do we have to adopt microservices?
No. For most systems, a modular monolith—a single application with clearly bounded modules—provides sufficient flexibility with less operational overhead. We separate only components that need independent scaling or releases by another team.
Do we have to move to the cloud?
No. The new platform can run on AWS, Azure or Google Cloud, or in your own data centre. If data must remain in Türkiye or the EU, the location is chosen accordingly. Cloud hosting is not cheaper for every system; we compare operating costs during discovery.
How are users affected during the transition?
Where suitable, users continue on legacy screens while a small group trials the new module. Data transformation or external connections may require a maintenance window; we do not guarantee a transition without downtime for every project. Reverse migration of new records, decision authority and the last safe rollback point are rehearsed beforehand. Training is delivered in short sessions, with an open support channel for questions in the first weeks.
What if the company that built the old system no longer exists?
We inspect source code if available; otherwise, we examine the database and externally visible behaviour—screens, reports and output files. Rules are identified with users and through comparisons during parallel running. Before accepting a takeover, we clarify source-code usage rights, database backups and restore tests, infrastructure access, licences and ownership of external connections. We do not commit to maintaining an existing system or taking over every technology before reviewing it. Do not send passwords or production data at the first meeting; we plan necessary access and sample-data sharing separately.
Can we see your reference projects?
We present product concepts instead of a customer reference list: interface designs for fictional companies showing how a particular problem could be solved. To limit risk, we suggest a fixed-fee discovery sprint and a small, reversible module as the first stage.
Next step
Tell us about your current system and what you want to change. Let's clarify missing details by email, then define the scope for assessment and the first transition stage.