FR

Java Application Modernization Service in Switzerland

We are a Geneva-based custom software development company providing a Java application modernization service for Swiss organizations running outdated Java applications. Whether your codebase is stuck on Java 8, blocked by tangled dependencies, or impossible to deploy without manual steps, we take it from there to a modern, secure, containerized stack — on a fixed-price contract with a written 12-month bug-free warranty.

Get a modernization assessment   contact@meylan-tc.com

  • Java 8 / 11 → Java 17 / 21 upgrades, including Spring Boot 2 → 3 (javax → jakarta) migrations
  • Dependency hell resolution — incremental, test-backed, no big-bang rewrites
  • Containerization & CI/CD — Docker, Kubernetes-ready, automated pipelines
  • Fixed-price, written 12-month bug-free warranty on every delivery
  • Geneva, Switzerland — senior on-shore team, available across Suisse Romande

Why Java modernization matters

Java has been a backbone of enterprise software for over 25 years. The downside of that stability: many production Java applications today were last meaningfully updated years ago. Running on Java 8 (public free updates ended in 2019) or unsupported framework versions exposes you to:

  • Known security vulnerabilities in dependencies with no available patches.
  • Expensive long-term support licenses (Oracle, Red Hat) just to keep receiving fixes.
  • Hiring difficulty — strong developers do not want to work on a stack from 2014.
  • Rising upgrade cost — every month you wait, more breaking changes accumulate between you and a current stack.

Most organizations know they need to modernize. The question is how to do it without breaking production. That is what this service is for.

What our Java modernization service delivers

1. Modernization assessment (1–2 weeks)

We start with a scoped technical assessment:

  • Java version, framework versions, build system inventory
  • Dependency tree analysis — vulnerable libraries, abandoned libraries, upgrade blockers
  • Test coverage and CI/CD maturity
  • Deployment process review
  • Architecture and coupling assessment
  • A prioritized modernization roadmap with effort estimates and a fixed-price proposal for execution

You walk away with a credible plan and a concrete number — not vendor talking points.

2. Establishing the safety net

Before changing anything load-bearing, we add the tests that are missing:

  • Smoke tests on the critical business paths
  • Integration tests at the system boundaries
  • Regression baselines against current behavior

This is the foundation that makes every subsequent change safer. Without it, modernization is gambling.

3. Build and CI pipeline modernization

  • Migration from Ant or legacy Maven to modern Maven / Gradle
  • Reproducible builds, automated tests, deployable artifacts on every commit
  • Continuous integration setup (GitLab CI, GitHub Actions, Jenkins)

Modernizing the build first is the single highest-leverage change. It pays for itself within weeks.

4. Dependency cleanup, incrementally

This is where most modernization projects bleed time. We work through dependencies one at a time, prioritized by:

  • Known security vulnerabilities (CVEs)
  • Upgrades that unblock other upgrades
  • Risk vs. value ratio

Each upgrade ships behind the test suite. No big-bang releases. No "we'll fix it later".

5. Java version upgrade — Java 8 → 21

Once the foundation is stable, we move Java versions in safe steps: typically Java 8 → 11 → 17 → 21. Each jump has its own gotchas (module system, removed APIs, GC changes, javax → jakarta) and we handle them surgically.

6. Containerization and modern deployment

  • Docker images optimized for your runtime
  • Kubernetes manifests or Docker Compose for orchestration
  • Replacement of manual deployment runbooks with automated pipelines
  • Removal of dependencies on legacy application servers (older JBoss, WebLogic, Tomcat) where it makes sense

7. Architecture refactoring (only where it pays)

Once the foundation is solid, we address architectural debt driven by business priorities, not technical perfectionism. Decoupling, proper layering, and selective rewrites — not a rewrite-the-world project.

How we work

  • Fixed-price contracts. Clear scope, predictable cost, no time-and-material overruns.
  • Written 12-month bug-free warranty. Every production bug we ship is fixed free of charge for 12 months. See our zero-bug guarantee.
  • Incremental delivery. Small, frequent releases — never a year-long radio silence.
  • Senior Swiss engineers. Based in Geneva, available across Suisse Romande and remotely for international clients.

Who this is for

  • Mid-sized organizations in Switzerland running Java applications built between 2010 and 2018 that are now hard to maintain.
  • Internal IT teams who lack the bandwidth (or recent Java expertise) to handle a modernization in addition to BAU.
  • Acquired companies / post-merger environments where a Java application from one entity needs to be brought up to the new parent's standards.
  • Pre-cloud-migration cleanup — modernizing the application stack before moving to AWS, GCP, Azure or a managed Kubernetes platform.

If your application has been declared "too risky to modernize", that is exactly the kind of project we take on.

Frequently asked questions

How long does a typical Java modernization take? A focused engagement on a single application — Java 8 → 21, dependency cleanup, CI/CD, containerization — typically runs 2 to 6 months depending on application size and dependency state. Larger architectural refactoring is scoped separately.

Will you rewrite our application? Almost never. Big-bang rewrites are slower, riskier, and more expensive than incremental modernization. We rewrite specific modules only when modernization is genuinely impossible.

What about Java EE / Jakarta EE applications? Yes — we handle the javax → jakarta namespace migration, application server migration (WebLogic / older JBoss → modern Tomcat / WildFly / embedded), and the Spring 4/5 → 6, Spring Boot 2 → 3 jumps.

Do you only work with Java? The bug-free warranty and fixed-price model apply across our custom software development service in Geneva. Our specialty is Java; we also handle Kotlin, modern JVM stacks, and adjacent backend ecosystems.

Can you work with an existing offshore team? Yes. We often act as the senior on-shore Swiss anchor — design, modernization decisions, code reviews, quality gate — alongside an existing offshore team handling volume work.