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.
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.
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.
The version the application already builds on, and a current LTS when we are starting a new service. Moving an old service to a newer JDK is its own piece of work, with the test suite as the gate, not a side effect of an unrelated feature.
Yes. That is a common shape: a new package or a new Spring service that owns one area, with the monolith calling it or being called by it. The data ownership is decided before the first endpoint is published.
With the approach already in the codebase when there is one: JPA, jOOQ, JDBC, or Spring Data. A new service gets one of those, chosen for the queries it has to run, and the schema change ships with the code that uses it.
Java is the service and the job. React or another front end calls it. Cloud hosting, including Microsoft Azure when the company already runs there, is a separate decision from the language. Custom development is the page for the wider product shape around that service.
Keep the JVM application you have
Tell us the JDK, the framework, and the change you need. We will work inside that build.