Java & Legacy PHP Monolith Re-Platforming Nordic & EU delivery Direct email access

Re-Platform Java and Legacy PHP Monoliths into Governed Cloud Services

DevNord re-platforms ageing Java EE and PHP monoliths into modular Spring Boot and PHP 8.x services on modern cloud infrastructure. Characterisation tests capture today’s behaviour before any refactor begins.

2 weeksTo a ranked migration map
99.99%Target availability design goal
30 daysPost-launch hypercare included
System architecture

Input layers → DevNord pipeline → multi-cloud infrastructure → security & observability

This is the service-specific architecture we design and operate. Inspect any node to see its role, the engineering or QA control around it, and how risk is contained.

01 / INPUT & CURRENT STATE02 / DEVNORD ENGINEERING + QA PIPELINE03 / MULTI-CLOUD INFRASTRUCTURE04 / SECURITY & OBSERVABILITYJava EE / WAR — A monolithic EAR/WAR bundles every domain. We map EJBs, listeners and JNDI references before extracting anything.Java EE / WARSingle deployableLegacy PHP Modules — Older PHP code paths hide dependencies in includes and globals. Static analysis turns that implicit graph into something testable.Legacy PHP ModulesGlobal includes + stateShared RDBMS — One schema couples unrelated features. We identify foreign-key boundaries and design per-service ownership.Shared RDBMSOracle / MySQLCode Archaeology — We combine bytecode/include analysis with runtime traces to find the real dependency graph, not the documented one.Code ArchaeologyAI-assisted call graphsAnti-Corruption Layer — A thin adapter translates legacy DTOs into clean domain contracts, keeping old quirks out of new services.Anti-Corruption LayerProtocol translation seamCharacterisation Tests — We record current outputs and side effects as tests, giving a precise definition of "no regression" for each extraction.Characterisation TestsPlaywright + API specsSpring Boot / PHP 8.x — Small, stateless services with explicit health endpoints, structured logs and rolling deployment strategies.Spring Boot / PHP 8.xContainerised servicesManaged PostgreSQL — Each bounded context owns its schema, migrations and backups, deployed through reviewed IaC modules.Managed PostgreSQLPer-service databasesAPI Gateway + Kubernetes — Versioned north-south traffic, service discovery, and a pipeline that promotes only green builds.API Gateway +KubernetesAKS / EKS / Container AppsIAM & Least Privilege — Role-based access, managed identities and short-lived credentials are applied to every environment in this engagement. This is applied to the Java & Legacy PHP Monolith Re-Platforming delivery.IAM & Least PrivilegeAzure Entra ID / AWS IAMNIS2 & GDPR Controls — Encryption, residency, retention and evidence are encoded as controls so the architecture can be audited, not just described. This is applied to the Java & Legacy PHP Monolith Re-Platforming delivery.NIS2 & GDPR ControlsPolicy as code · EU regionsObservability & Audit Trails — Dashboards and alerting cover the paths changed by this service, with immutable audit trails for release and access decisions. This is applied to the Java & Legacy PHP Monolith Re-Platforming delivery.Observability & AuditTrailsLogs · metrics · traces · alerts
01 / INPUT & CURRENT STATE
02 / DEVNORD ENGINEERING + QA PIPELINE
03 / MULTI-CLOUD INFRASTRUCTURE
04 / SECURITY & OBSERVABILITY

Tap any node to inspect it.

Hover over a node to inspect it.

Node inspectorSelect any component to see what it does, which control protects it and how we hand it over.

Development plan

Week-by-week roadmap to production

An indicative 12-week cadence for a full engagement. The exact calendar, milestones and price are fixed in your EUR (€) or SEK (kr) proposal after discovery.

Indicative cadence — finalised in your fixed-scope proposal

01
Week 1–2

Phase 1: Discovery, Requirements & Architecture Blueprint

Runtime versions, framework coupling and deployment topology are inventoried to size the re-platforming surface.

02
Week 3–6

Phase 2: Core Sprint Engineering & Iterative Milestones

Bounded contexts are carved out behind versioned contracts while the monolith continues to serve traffic.

03
Week 7–9

Phase 3: Hybrid QA Validation (Manual UAT + Automated Regression)

Manual journey tests cover locale and data edge cases while Playwright and API contracts gate each extracted service.

04
Week 10–12

Phase 4: Zero-Downtime Production Deployment & Handover

Traffic shifts to the new services behind a proxy; build scripts, IaC and ownership docs are transferred to your team.

How We Work

Delivery standards that make outcomes predictable

Every engagement runs with the same operating model: senior squads, transparent ownership and written evidence at every gate.

Two-week sprint cadence with demoable increments and a written decision log.

Transparent Git repository ownership — repositories land in your organisation from day one.

Infrastructure-as-code (Terraform or Bicep) for every environment, reviewed and reproducible.

Fixed-scope proposals in EUR (€) or SEK (kr), with capped B2B consulting retainers when scope is still emerging.

Bilateral NDA signed before source code, architecture data or credentials are shared.

Technical overview

What we actually engineer

Legacy Java and PHP monoliths fail because every change shares one blast radius. DevNord captures behaviour first, then extracts bounded contexts into separately deployable services with explicit contracts. The monolith keeps earning its keep until each new slice has passed manual and automated validation.

We support upgrades to maintained Java LTS runtimes and modern PHP versions on modern cloud infrastructure, with EU-region hosting where configured. Every engagement is quoted as a fixed-scope proposal in EUR (€) or SEK (kr).

The bottleneck

One deployable artefact means one shared blast radius

A decade of features has fused into a single WAR file or PHP codebase. Framework versions are frozen, the test suite is manual, and a small change in one module can take down unrelated workflows.

  • End-of-life Java EE containers or PHP 5/7 runtimes with known CVEs
  • Framework upgrades blocked by implicit global state and includes
  • A single database schema shared by unrelated domains
  • No reliable way to prove behaviour stayed identical after a change
The DevNord approach

Capture behaviour first, then carve out bounded contexts

We generate a call graph across Java classes or PHP includes, record characterisation tests against the running system, and introduce an anti-corruption layer. Modules then move one at a time to containerised services with their own data.

  • Static analysis for Java bytecode and PHP dependency graphs
  • Characterisation tests that freeze current behaviour as executable specs
  • Spring Boot or PHP 8.x services with explicit contracts and ownership
  • Managed PostgreSQL/MySQL and object storage in EU regions
Business outcome

What changes after this engagement

01

Upgrade without guesswork

Recorded behaviour proves the new service matches the old one before traffic moves.

02

Independent release cadence

Small services ship on their own schedule instead of waiting for a monolithic release train.

03

Security runway restored

Supported runtimes, patched base images and policy-as-code close the CVE backlog.

Deliverables checklist

Concrete artefacts you receive at handover

These are service-specific, reviewable assets — not status reports. Your team owns each one.

  • Runtime and dependency upgrade matrix
  • Bounded-context map with data ownership
  • Versioned OpenAPI or gRPC contracts
  • Containerised Java or PHP services on modern cloud infrastructure
  • Characterisation and Playwright regression suites
  • Build, release and rollback runbooks
Questions, answered

The things decision-makers ask us first

Still unsure? Write to us at [email protected] — we reply in plain language, without a sales script.

Do you rewrite the application from scratch?

Almost never. A full rewrite repeats bugs you have already learned to live with. We extract bounded contexts behind a proxy and keep proven business logic until it is safely replaced.

Can legacy PHP and new Java services coexist?

Yes. The strangler proxy is language-agnostic. We routinely route some paths to PHP 8.x and others to Spring Boot while the old monolith still owns the remainder.

How do you test a system with no tests?

We create characterisation tests from observed behaviour and real production traffic patterns. These become the acceptance criteria for every extracted service.

What if the database is the real bottleneck?

We include data ownership in the Blueprint Audit. Where needed, we introduce per-service schemas and change-data-capture patterns so domains can separate without a stop-the-world migration.

Next step

Make your next Java or PHP upgrade predictable

Start with a fixed-scope Blueprint Audit and get a ranked, testable extraction plan for your monolith.