Skip to content

Java EE modernization services

We provide Java EE modernization services for companies running enterprise applications on application servers. We plan JDK and server upgrades, migration to Jakarta EE, and selective extraction around the transactions, access controls and integrations the business depends on.

01Capabilities

Engineering the application-server estate

Our enterprise Java engineering covers the configuration and services an application server supplies at runtime. New systems and Spring Boot platform design sit on our Java development page.

  • Patching

    Keeping an estate supportable while it keeps running

    We assess estates on JBoss, WildFly, WebLogic, WebSphere and GlassFish, checking the JDK/provider/server combination. Patch currency, database connections, class-loading behaviour and the release process define the initial legacy modernization scope.

  • Rename

    Migration from javax to jakarta APIs

    We plan Jakarta EE migration around the affected javax-to-jakarta APIs, deployment descriptors, dependencies and server compatibility. We verify transaction and security behaviour before and after each staged change.

  • Extraction

    Extracting an endpoint or scheduled job

    We move a selected endpoint or scheduled job onto a plain Java runtime behind a stable interface. We define the dependencies and rollback plan for that step, then decide whether further extraction serves the business.

  • Interfaces

    Queues, batch runs and service contracts

    We map queues, scheduled batch runs and existing service contracts, including their callers in fintech and logistics ERP estates.

02Fit

Maintain, upgrade or selectively extract

We choose the scope based on supported configurations, required business changes and the behaviour the application server supplies. Maintenance, a bounded upgrade, namespace migration and selective extraction remain distinct decisions.

Six situations, and what we would tell you in each
Your situationWhat we recommend
A business application that depends on server-managed behaviour Work in placeDocument the configuration, test transactions and interfaces, and upgrade against verified compatibility. Extract a module only when a defined business change calls for it.
A new Java system, Spring Boot or general platform architecture Java platform workOur Java development page covers new Java systems, Spring Boot back ends and platform architecture. The application-server decision is assessed separately where relevant.
A new enterprise system without an established application-server requirement Start on Spring BootUse Spring Boot for new platform work when the application fits that operating model. Jakarta EE remains an option when server-managed responsibilities and the existing estate require them.
A support or compatibility gap concentrated in the server and namespace transition Keep it containedScope the JDK/server and dependency work needed for compatibility. Keep domain redesign separate unless the business rules themselves need to change.
Business rules or system boundaries need redesign Redesign the domainA domain redesign addresses structural changes to the business rules or system boundaries. Package and server changes remain a separate scope.
A patched, supported estate with documented interfaces and required releases unblocked Keep the estateMaintain the current configuration and its security updates. Reassess when a support change or required capability creates a concrete migration need.

Scope

We own the upgrade plan, transaction and access-control behaviour, and the impact on systems calling the estate. The scope includes compatibility checks and a recovery plan for each stage. We run this work under an ISO 27001:2022 certified information-security management system, alongside ISO 9001:2015. unicrew has been building software since 2012, with 100+ senior in-house engineers across six countries.

A great deal of enterprise Java runs businesses quietly and correctly. We decide what to rewrite by whether each module can still be changed safely. We upgrade the rest in place, one step at a time, with a working deployment after each.

Oleksandr TrofimovChief Technology Officer, unicrew

03Delivery

Finding the behaviour that lives outside the source code

An application-server estate includes behaviour defined in deployed configuration. We inspect and test that behaviour alongside the source code before choosing the upgrade sequence.

  1. Inventory the server-owned configurationWe record connection pools, queue destinations, security settings, transaction configuration, class-loading behaviour and vendor-specific files. These deployed settings are assessed alongside the repository and deployment files.
  2. Test the deployed interfacesWe test transaction, security and integration behaviour through the deployed interfaces. These checks establish baseline behaviour for validating server and namespace changes.
  3. Sequence changes by verified compatibilityWe check the supported JDK, server and dependency combinations before sequencing the namespace changes. We verify a working deployment after each agreed step, with a recovery plan for that step.
  4. Set boundaries before deciding on extractionWe define module boundaries inside the estate before deciding which modules to extract. The decision follows the business change, dependencies and interfaces, with a transition plan for each selected piece.

04Stack

What an application server sits between

Use the surrounding stack pages to assess Java, data connections and the deployment path alongside the application server.

05Questions

Asked when the support renewal lands

Clarify server compatibility, namespace scope, maintenance and delivery responsibility before commissioning a Java EE change.

Yes. Our engineers own the Java EE change plan as well as the implementation, with delivery coordination alongside your team.

An architect outside the delivery team reviews the upgrade order and recovery plans.

Choose managed teams for ongoing estate engineering with delivery coordination, or legacy modernization for a defined upgrade or migration scope.

Jakarta EE fits a new application when its server-managed capabilities suit the system and operating model.

We weigh transaction and security responsibilities, existing operations, support and maintainability. We also assess Spring Boot for new Java platform work against those requirements.

Our Java EE work focuses on applications whose behaviour depends on the application server.

That includes server-managed transactions, security settings, vendor configuration and affected javax-to-jakarta APIs. Our Java development page covers Java platform design, Spring Boot and new back ends.

Jakarta EE migration includes package changes, dependency and server compatibility, and verification of application behaviour.

The Java EE/Jakarta EE naming change predates the namespace change. Jakarta EE 8 retained Java EE 8 API names; Jakarta EE 9 changed affected javax packages to jakarta and is not source- or binary-compatible with earlier platform versions.

  • Check imports, deployment descriptors/properties and dependencies against the target server.
  • Verify transaction, security and data-handling behaviour.
  • Keep Java SE APIs such as javax.sql and javax.naming unchanged.

Yes, when the estate remains supported, patched and able to deliver the required changes.

We check the JDK distribution and provider entitlement, server security updates, release constraints and documented interfaces. Unsupported components require a support or upgrade plan tied to the actual version, dependencies and business needs.

We start with a scoping call with an engineer.

We ask for read access to the repository, server configuration and deployment files. You receive a written recommendation covering upgrade order, what to extract, what to keep and where risk is concentrated.

Most engagements start within two to four weeks.

We quote Java EE work against the estate and agreed migration scope.

  • Time and materials: billed hourly and quoted per project.
  • Fixed price: outcome based and quoted per project.
  • Team extension: billed monthly per team member.

Fixed price is agreed once the initial assessment defines the delivery boundaries.

Plan your Java EE estate's next change

Tell us the server, JDK version and systems the application connects to. We will recommend the order of work, what to keep and where selective migration fits.

Book a scoping call

Thank you

Thanks for your message. We will get in touch with you shortly.