Software Modernisation and Architecture Consulting – Refactor Beats Greenfield

Why Strategic Consulting?

The decisions you make at the beginning of a software project have long-term consequences. The wrong technology or architecture can cost you years and hundreds of thousands of euros.

Typical Costly Mistakes We Prevent:

• Wrong Technology Choice: Developing native apps for iOS/Android when cross-platform would be 50% cheaper
• Over-Engineering: Building microservices architecture for an MVP (Cost: +€50k, Time: +6 months)
• Under-Engineering: No scaling planned, complete rebuild needed when growing
• Vendor Lock-in: Too dependent on one cloud provider or framework
• Feature Bloat in MVP: 6 months developed, but 80% of features aren't used
• No Privacy Strategy: GDPR compliance only after launch, then expensive refactoring

Our consulting costs a fraction of what you save by avoiding mistakes.

Software Modernisation: Refactor and Extend Instead of Greenfield

Most mid-market software we deal with is not „broken“ — it has grown. A system that started narrow and deliberate five, seven, or ten years ago today carries layers of additions, workarounds, and silent domain knowledge. At some point it constrains the business: performance buckles under load, schema migrations turn brittle, an old SDK drops out of support, a new regulation kicks in. The first reflex is often: „let us rebuild it from scratch.“ That is usually the most expensive, slowest, and riskiest option. A clean software modernization — refactor and targeted extension — is in most cases faster, cheaper, and preserves the domain knowledge that has settled into the code over years.

When software modernisation is the right call

Modernisation pays off when the system is fundamentally sound but is stuck on one of the points below. Greenfield only becomes the option when several of these signals hit at once and the data model cannot be salvaged.

• Performance ceiling hit: response times tip over as data grows, hardware upgrades stop helping — the bottleneck sits in the data model or the query path
• Schema migrations turn brittle: every new column drags downstream reports and integrations along, adding a simple field becomes a multi-week project
• SDK or framework deprecation: a central third-party SDK drops out of support, the framework has made a major jump, security patches turn expensive
• Compliance deadline with architectural impact: EU Data Act (since September 2025), NIS2, AI Act, EU battery passport 2027, CRA — obligations that cannot be bolted on as a module but have to live in the data model and the API layer
• Cost-of-change too high: even small changes take days, test effort grows out of proportion, the team starts dodging changes near the core

Modernisation strategies — four patterns

A software modernization rarely runs as a single cut. In practice we combine four established architecture patterns, depending on the installed base, risk profile, and delivery pressure. Which mix fits gets settled in the architecture audit upfront — not in the pitch meeting.

Strangler Fig — replace piece by piece

The pattern goes back to Martin Fowler: you build the new system around the old one, route requests progressively to new components, and the old system fades out from the outside in. Live operation continues throughout, each step is independently reversible. Suited to systems with clear module boundaries and an auth layer that can serve as the routing point.

Refactor and Extend — keep the architecture, replace the internals

Our bread-and-butter pattern for grown mid-market systems. The outer architecture and the API contracts stay stable, the internals get deliberately rewritten step by step — data model decoupled, auth layer modernised, event log added. Extensions land during the refactor, not after it finishes. That is the path we took with LITE BLOX: from the system that grew since 2020, a complete refactor with targeted extension emerged across 2025–2026 — without end customers in the field feeling a break.

API-First Layering — wrap the legacy, build new on top

When the legacy system must not be touched — because it is regulatory-certified or simply too fragile — we wrap it behind a clean API layer. New modules, new frontends, new integrations only talk to that layer; the legacy system is taken off the risk path without having to be replaced. Useful as a transitional architecture or as a long-term solution, when the legacy runs stably.

Database Modernisation — schema migration without breaking consumers

When the pain originates in the data model, the rest is often still viable. We migrate the schema in several stages, keep read and write paths parallel during the migration — dual writes, backfills, per-table cut-over. Existing consumers stay functional until they move to the new model in a controlled step. With LITE BLOX, the lifecycle data model with a birth snapshot per unit is currently being rolled out across the installed base along exactly this path.

LITE BLOX as a worked example: modernisation under live operation

Anyone commissioning a software modernization wants evidence, not theory — proof that it has actually worked somewhere. LITE BLOX is a public case (industry partner LITEWERKS GmbH, design partner studio hak) that we use here as a proof anchor.

Starting point: a first digital platform for intelligent LiFePO4 starter batteries has been live since 2020 — five years of growth, proven in the market, not built for the 2026 regulatory demands (EU Data Act since September 2025, EU battery passport 2027). Nearly 6,000 active units in the field. Greenfield would have disrupted live operation, thrown away five years of domain knowledge, and blown the regulatory deadline.

Approach: a complete refactor and targeted extension of the system that grew since 2020. The central question was not „which features“, but „which building blocks have to be re-thought cleanly now so that the installed base stays alive and compliance, scaling, and a later AI evaluation come without another rebuild“. Data model, API contracts, and auth layer were restructured; existing field devices and customer accounts stayed productive throughout.

What is live today: refactored backend (NestJS) and mobile app (Flutter) on the new platform, nearly 6,000 active units run on it. Own cloud infrastructure in the EU, rolling Docker deployments, monitoring through Sentry and Grafana Cloud. In rollout: lifecycle data model with an immutable birth snapshot per unit, append-only event log for the revision-safe lifecycle history, self-service data export in the customer portal as a direct response to the EU Data Act. GDPR-compliant data handling and privacy by design across all frontends are anchored in the data model and API layer, not in a layer on top.

Full case with architecture, stack, and lessons learned: LITE BLOX showcase.

What we audit in a modernisation engagement

A serious modernisation engagement starts with an inventory. We deliver five concrete result blocks — not a slide deck, but documents you can make technical and commercial decisions on.

Investment range for software modernization

Three clearly cut entry tiers. Which fits depends on installed-base size, compliance pressure, and the desired delivery depth — we align that in the discovery call.

Architecture Review — 1–2 weeks · 8,000–15,000 €

Audit of the existing system, 30-page report with concrete findings, tech debt register, cost model refactor vs. greenfield, closing 4-hour workshop with decision-makers and tech lead. Solid basis without committing to a modernisation path yet.

Modernisation Pilot — 8–16 weeks · 40,000–120,000 €

Audit plus modernisation of the first one to three modules — e.g. auth layer, one central API endpoint, the most critical data model segment. Live operation continues throughout, each stage is reversible. You see the approach in your own installed base before deciding on end-to-end.

End-to-End Modernisation — from 24 weeks · from 150,000 €

Complete refactor with targeted extension, data model migration, new API layer, optional frontend modernisation — live operation stays in place throughout. End-to-end responsibility from architecture through implementation to operation. That is exactly the profile that ran with LITE BLOX.

Related reading

• Modernisation in context: Industry 4.0 — what the platform requirements for connected machines and IoT installed bases concretely mean.
• Typical modernisation output: Supplier portal — structured supplier integration instead of email attachments.
• Typical modernisation output: Self-service portal — direct response to data access rights from the EU Data Act.
• When the modernisation is primarily backend-driven: Backend Development — NestJS, PostgreSQL, EU and Swiss hosting.
• The full case: LITE BLOX showcase — architecture, stack, compliance, lessons learned.

Our Consulting Topics

1. MVP Strategy & Feature Prioritization

The most common mistake: Too many features in the MVP. We help you define the Minimum Viable Product that truly validates whether your idea works.

What We Analyze:

Deliverable:

• Prioritized feature list (Must-have, Should-have, Could-have, Won't-have)
• MVP roadmap with timeline
• User stories for MVP features
• Cost estimation

Typical Savings: 30-50% of initial development costs through smart feature reduction

2. Technology Evaluation & Selection

Flutter vs. Native? PostgreSQL vs. MongoDB? AWS vs. Google Cloud? We help you choose the right technology for YOUR requirements.

Areas of Our Technology Expertise:

Evaluation Criteria:

• Time-to-market
• Initial & ongoing costs
• Scalability
• Developer availability (Can you find other developers later?)
• Long-term maintainability
• Vendor lock-in risk

Deliverable:

• Technology recommendation report with pros/cons
• Cost-benefit analysis
• Risk assessment
• Migration path (if you want to switch later)

3. Software Architecture Design

Good architecture is invisible. Bad architecture costs you every day. We design architectures that scale with your business.

What We Design:

• High-Level Architecture: How do Mobile App, Backend, database, third-party services interact?
• Database Schema: Data modeling for performance and flexibility
• API Design: REST or GraphQL, endpoint structure, versioning
• Security Architecture: Authentication, authorization, encryption
• Scaling Strategy: Horizontal vs. vertical scaling, caching, load balancing (see Cloud Services)
• Deployment Architecture: CI/CD, environments (dev, staging, prod)

Deliverable:

• Architecture diagrams (C4 model or UML)
• Database schema (ERD)
• API specification (OpenAPI/Swagger)
• Security design document
• Deployment diagram

4. Code Review & Technical Audit

You already have an app, but you're unsure about code quality or architecture? We analyze your code and give you honest feedback.

What We Check:

• Code Quality: Readability, structure, best practices
• Security Issues: Known vulnerabilities, input validation, authentication
• Performance Bottlenecks: Inefficient queries, memory leaks, N+1 problems
• Technical Debt: How maintainable is the code long-term?
• Test Coverage: Are there sufficient tests?
• Dependencies: Outdated or risky libraries

Deliverable:

• Detailed audit report with severity ratings (critical, high, medium, low)
• Prioritized remediation roadmap
• Cost estimation for fixes
• Recommendation: Fix vs. rebuild

Typical Scope: 2-5 days audit, depending on codebase size

5. Build vs. Buy Decisions

Should you develop a feature yourself or use an existing tool? We help you make the most economically sensible decision.

Example Decisions:

• Authentication: Custom auth system vs. Auth0 vs. Firebase Auth?
• Payment: Custom payment integration vs. Stripe vs. payment gateway?
• Analytics: Custom dashboard vs. Mixpanel vs. Amplitude?
• Email/SMS: Custom infrastructure vs. SendGrid vs. Twilio?
• CMS: Custom admin panel vs. Strapi vs. Contentful?

Evaluation Criteria:

• Initial Cost: Development costs vs. service costs (first year)
• Ongoing Cost: Maintenance vs. subscription (year 2-5)
• Flexibility: Can you customize later?
• Time-to-Market: How quickly do you need the feature?
• Lock-in Risk: How difficult is a later switch?

6. GDPR & Compliance Consulting

Privacy is not optional in Germany. We help you be compliant from the start.

What We Cover:

• Privacy by Design: Privacy architecture from the start
• Consent Management: How do you obtain consents legally?
• Data Minimization: What data do you really need?
• Data Processing Agreements: Which DPAs do you need with cloud providers?
• Right to Deletion: Implementation of deletion functionality
• Data Portability: Export functionality for user data
• Hosting Location: EU hosting vs. US hosting (post-Schrems II)

Deliverable:

• GDPR compliance checklist
• Technical implementation recommendations
• Data processing inventory
• Privacy policy template (technical part)

Note: We are not lawyers. For legal advice, we recommend specialized privacy attorneys. We cover the technical implementation.

7. Rescue Missions – Project Recovery

Your project is getting out of control? Budget exceeded, no progress, poor code quality? We help you save the project or develop an exit strategy.

Typical Rescue Scenarios:

• Offshore team delivered unusable code
• Freelancer disappeared, code is undocumented
• Agency overcharged and underdelivered
• 6 months developed, but app doesn't run stable
• Budget exhausted, but MVP isn't finished

Our Rescue Process:

1. Emergency Assessment (1-2 Days): How bad is the situation?
2. Options Analysis: Fix vs. restart vs. pivot
3. Recovery Plan: Detailed roadmap for recovery
4. Cost-Benefit: Is recovery economically sensible?
5. Execution: We take over the project (if desired)

Deliverable:

• Emergency assessment report
• Recovery options with costs/benefits
• Recommendation: Save, restart, or shut down
• Recovery roadmap (if recovery makes sense)

Our Consulting Process

Phase 1: Discovery Call (30 Min, Free)

We understand your situation, goals and challenges. At the end, you know if we can help and how.

Phase 2: Deep Dive Workshop (2-4 Hours)

Intensive session where we dive deep into your requirements. We ask many questions, challenge assumptions, identify risks.

Phase 3: Analysis & Research (1-5 Days)

We analyze, research, evaluate options, create comparisons.

Phase 4: Recommendations Report

Detailed report with recommendations, justifications, roadmaps, cost estimates.

Phase 5: Presentation & Q&A (1-2 Hours)

We present our recommendations, answer questions, discuss trade-offs.

Phase 6: Implementation Support (Optional)

If desired, we also implement the recommended solutions (see Mobile App Development, Backend Development, Cloud Services).

What Does Consulting Cost?

When Is Consulting Worth It?

Consulting Is Worth It When:

• You have a budget > €50k for development (consulting easily saves you €10-20k)
• You're technically uncertain and want to avoid costly mistakes
• Your project failed and you need a second opinion
• You must decide between multiple technologies/vendors
• You've already developed but have performance/security problems

Consulting Is NOT Needed When:

• Your project is very simple (e.g. simple landing page)
• You already have clear requirements and tech stack
• You only need development capacity (then directly Mobile App Development)

Why IntegrIT Solutions for Consulting?

• Practitioner, Not Theorist: We develop ourselves and know the practice
• 10 Years Experience: We've built dozens of projects (and seen mistakes)
• Honest Recommendations: We recommend the best solution, not the most expensive
• Implementation Possible: If desired, we also implement our recommendations
• Independent: We're not tied to specific technologies/vendors
• GDPR Expertise: We know German/European compliance requirements

Start with Free Initial Consultation

Unsure which technology is right? Your project not going as planned? Need a second opinion? Book a free 30-minute initial consultation. We listen, ask questions and show you how we can help.