Skip to main content

Java Development

JVM systems that stay maintainable

We design, extend, and maintain Java services: Spring Boot for newer APIs, Jakarta EE where the application already lives there, and the batch and integration jobs that sit beside both.

Illustration for Java development services

What we build with Java

Java work here is server-side. We use the JVM, a build you can reproduce, and a module boundary that a later change can find.

  • Spring Boot services

    New HTTP services are usually Spring Boot: controllers or functional routes, Spring Security where the API needs an identity, and Spring Data or jOOQ against the database you already have. Dependencies stay in Maven or Gradle, pinned, with a build that fails when the lockfile drifts.

    We keep the service bootable from a main class and from a container. Configuration comes from the environment, not from a file that only exists on one laptop.

  • Jakarta EE and existing JVM applications

    Plenty of Java worth keeping is not a new Spring service. We work in Jakarta EE and in the older Java EE layouts still running in application servers: servlets, CDI, JPA, and the deployment descriptor the server actually reads.

    A change in that codebase starts by reading the modules that already exist. We do not open a rewrite because a newer framework is more familiar.

  • APIs, messaging, and batch

    Services expose REST with an explicit contract. Where the system already uses a queue, we add producers and consumers on that broker, JMS or Kafka, instead of inventing a second channel.

    Scheduled work stays in its own entry point: Spring Batch, a Quartz job, or the scheduler the current application uses. A batch failure is visible as a failed job, not as a request that timed out.

  • Tests that follow the module

    JUnit covers the domain rules. An API change also gets a test that boots the slice and calls the endpoint. Testcontainers is the default when the test needs a real database or broker, so the suite is not asserting against a mock that hides a SQL mistake.

Typical use cases

Java is the right tool when the system is already on the JVM, or when the service has to live for years beside a relational database and a set of internal callers.

  • An internal API in front of a relational database

    Several applications need the same customer, policy, or inventory rules. We put those rules in a Java service with a documented API, and we stop copying the SQL into each caller.

  • A module added to a monolith

    The current WAR or Spring application can take a new package with a clear boundary. We add the module, its schema changes, and its tests, and we leave the unrelated packages alone.

  • A nightly or hourly job

    Files arrive, records need reconciling, or a downstream system wants a feed. We build that job on the JVM, with a rerun story for the rows that failed, rather than hiding it inside a web request.

  • A service that has to meet an existing security model

    The company already has an identity provider and a set of roles. We map those into Spring Security or the application server's constraints, and we test the paths that must stay forbidden.

How we work

Java engagements start in the repository you have. The first week is for the build, the runtime, and the boundary of the change.

  • Read the build before writing features

    We identify the JDK version, Maven or Gradle, the application server if there is one, and the tests that already run. A feature that does not build the way the team builds is not done.

  • Agree the package boundary

    New code goes in a package or module with a public API small enough to name. Callers inside the same repository use that API. Reaching into another module's internals is a review comment, not a shortcut.

  • Prove the endpoint and the job

    Unit tests cover the rules. A running slice covers the HTTP contract or the batch step, including the failure we expect when a dependency is down. We do not treat a green unit suite as proof the service starts.

  • Release beside the current deployment

    The artifact is the one your pipeline already knows, or a container if that is how this service is deployed. We add the health check and the log fields operators use, and we roll out next to the version that is live.

Bring the repository, including the old parts

Spring Boot, Jakarta EE, or a mix of both. We will tell you what we would change first and what we would leave on the current JDK.

Schedule a call

Why OLIANT

Java at OLIANT includes the application you already run, not only a greenfield Spring service.

  • Old and new Java in one review

    We read application-server layouts and Spring Boot services with the same care. The recommendation follows the code that is in production.

  • The JVM stays operable

    Memory, startup, and dependency updates are part of the change. A service that only works with a hand-tuned laptop JDK is not finished.

  • A boundary you can point at

    Packages, public types, and tests mark what the change owns. The next developer can find the edge without an oral history.

Frequently asked questions

Practical questions about Java work, before a project starts.

No. Spring Boot is the usual choice for a new service. Jakarta EE and existing application-server code are in scope when that is what production runs. We will not propose a framework migration as the price of a small feature.

Keep the JVM application you have

Tell us the JDK, the framework, and the change you need. We will work inside that build.

Illustration for the Java development closing invitation