FIXED SCOPEone-off build
Ship a Java product, end-to-end.
A defined product, a fixed price, a senior-only team. From RFC to launch in 8–14 weeks.
$15k–$30k
FIXED SCOPE
- Senior engineers only
- Fixed quote in week 1
- Code, infra, runbook — yours
Java backendsbuilt for the system that can't go down.
We don't follow tutorials — we ship Java in production. Twelve years of it. Spring Boot services that survive GC pauses under load, thread pools tuned for actual traffic patterns, distributed transactions that don't lose data. The JVM is the most battle-tested runtime in enterprise software — most teams still don't operate it like one.
- Spring Boot 3
- Sub-50ms p99
- Virtual threads
- Observable by default
Why Entalogics for Java
Four things every
Java app
actually needs.
Here's what actually breaks Java in production — thread pool exhaustion nobody sees until the dashboard flatlines, JPA doing thirty queries where it should do one, Spring context startup times that make autoscaling useless, and a config mess split across six YAML files nobody owns. We've inherited all of it.
Performance01
JVM tuning isn't optional. It's the product.
GC pauses, heap sizing, thread pool configuration — these aren't devops problems. They're architecture problems that surface under real traffic. We profile before we ship, not after the first latency alert.
Architecture02
Modules with boundaries, not a package soup.
Spring makes it easy to autowire anything from anywhere. That's the trap. We enforce bounded contexts with explicit module APIs, constructor injection only, and package-private classes that prevent the dependency graph from becoming everyone's problem.
State03
JPA where it earns it. JDBC where it doesn't.
Hibernate is powerful and dangerous in equal measure. Lazy loading that fires in a controller. N+1 selects hidden behind a clean repository interface. We use JPA for complex domain models and Spring JDBC or jOOQ for read-heavy paths where the ORM overhead isn't justified.
Type safety04
Records, sealed types, and compile-time contracts.
Java 21 records for DTOs. Sealed interfaces for domain state machines. Bean Validation at every API boundary. When a domain type changes, the compiler catches every downstream break — not the integration test suite three hours later.
When Java, when not
Java is a tool.
Not a religion.
Not every problem needs the JVM. We'll tell you on the first call if Java is genuinely the right fit — or if you're paying for ceremony your product doesn't need.
PICK JAVA WHEN
- The system can't go down — finance, payments, healthcare — where the JVM's operational maturity matters
- You have a large team that needs the compiler and Spring's conventions enforcing structure across 20+ engineers
- Long-lived platform with serious backward compatibility and enterprise integration requirements
- You need deep observability out of the box — Actuator, Micrometer, OpenTelemetry all first-class
CONSIDER OTHERS WHEN
- Lightweight APIs where startup time matters — Java's cold start penalty is real in serverless
- Small team prototyping fast — Spring's ceremony costs more than it saves at that stage
- The team ships Python or Node.js well and there's no enterprise integration forcing the choice
WE SAY NO WHEN
- "We want Java because enterprise uses it." That's procurement habit, not architecture thinking.
- "Just add Spring Boot around our legacy servlets." We'll tell you honestly if that's the right path.
- "We need this in three weeks and the domain model changes daily." That ship has sailed.
What we build with Java
Six product surfaces.
One quality bar.
The shapes of Java work we take on most — enterprise-grade, high-reliability, built to still be maintainable when the third team inherits it.
- S01
SaaS API platforms
SaaS API platformsSpring Boot 3 with virtual threads, Bean Validation at every boundary, Actuator and Micrometer wired from day one. APIs that are observable before they're launched.
SPRING BOOT 3VIRTUAL THREADSMICROMETERPOSTGRES - S02
Financial & payment systems
Financial & payment systemsTransaction integrity at every layer. Distributed sagas, idempotency keys, audit trails baked in. The kind of backend where "eventually consistent" isn't an acceptable default.
SPRING BOOTKAFKAAXONPOSTGRES - S03
Event-driven microservices
Event-driven microservicesKafka for event streaming, Spring Cloud for service discovery, circuit breakers and retry logic that don't hammer dead services. Systems designed to fail gracefully — not cascade.
KAFKASPRING CLOUDRESILIENCE4JOPENTELEMETRY - S04
Enterprise integrations
Enterprise integrationsLegacy ERP connectors, SOAP-to-REST bridges, message queue middleware. Java's enterprise ecosystem handles integration surfaces no other language touches.
SPRING INTEGRATIONACTIVEMQCAMELSOAP - S05
Internal tooling
Internal toolingReplace the spreadsheet. Replace the five spreadsheets. Replace the internal portal three departments use but nobody maintains.
SPRING BOOTTHYMELEAFHTMXTAILWIND - S06
Legacy Java migrations
Legacy Java migrationsJava 8 to Java 21, Spring MVC to Spring Boot 3, monolith to modular monolith. Service by service — the current platform keeps running while we modernise underneath.
SPRING BOOT 3JAVA 21JOOQFLYWAY
The playbook
Patterns we
ship on repeat.
Proven in production under real enterprise load — not demo apps.
P01
Virtual threads by default
Java 21 virtual threads replace reactive complexity for I/O-bound work. Millions of concurrent tasks without the callback hell of Project Reactor. Simpler code, same throughput.
P02
Typed contracts at every boundary
Bean Validation on inbound requests. Records for DTOs. OpenAPI specs generated from code — not maintained separately. The contract is wrong at compile time, not at runtime.
P03
JPA with guardrails
Entity graphs defined per use case. `@BatchSize` and fetch joins configured explicitly. N+1 detection in CI with query count assertions. Hibernate used with discipline — not trusted blindly.
P04
Event sourcing where it earns it
Kafka with Axon or custom event store for domains where audit trails and replay are actual requirements. CRUD everywhere else. We don't event-source a user profile.
P05
Integration tests against real infrastructure
Testcontainers for Postgres, Kafka, Redis — tests run against real services, not mocked interfaces that behave differently under load at 3am.
P06
Strangler-fig migrations
New Spring Boot 3 services behind a gateway, running alongside the legacy application. One endpoint at a time. The old system keeps serving until the new one has earned every route.
Signature case
A payments platform,
modernised without missing a transaction.
A B2B payments platform on Java 8 with Spring MVC — 1.2s p99 on transaction endpoints, thread pool exhaustion under peak load, a monolithic WAR deployed every two weeks with a 30-minute maintenance window. Migrated to Spring Boot 3 with virtual threads and modular bounded contexts in 14 weeks. Zero transactions dropped.
Before
p99 transaction 1.2s · thread pool exhaustion at peak · 30-min deploy window · monolithic WAR
After
p99 transaction 68ms · virtual threads, no pool exhaustion · zero-downtime rolling deploy · modular services
- p99 transaction latency−94%
- Deploy downtime−100%
- To fully migrated14wk
- Shipped regressions0
Engagement shape
Eight to ten weeks
to a measurable ship.
One service at a time. The legacy platform keeps processing transactions the entire time.
- W01
Audit + RFC
Two senior Java engineers in the codebase. JVM profiling, thread pool analysis, JPA query audit, dependency graph review. A ranked, dollarized RFC — not a slide deck of code smells.
- W02–03
Foundation + first service
Spring Boot 3 baseline, virtual threads enabled, Actuator and Micrometer wired in, one production service migrated end-to-end. Real p99 numbers in your dashboards.
- W04–08
Migrate by service, not flag-day
Service by service behind a gateway. Old and new run side-by-side. Kill-switch on every cutover. Your roadmap keeps moving.
- W09+
Cleanup + handoff
Decommission the legacy WAR. Integration test coverage on critical paths. Runbook handed to your team — or we stay on retainer.
Stack
Tools we
reach for first.
Picked for production reliability under enterprise load. Already on a stack? We slot in.
- FrameworkSpring Boot 3 · Spring Cloud · Quarkus · Micronaut
- LanguageJava 21 · Kotlin · Bean Validation · Lombok
- DataJPA/Hibernate · jOOQ · Spring JDBC · PostgreSQL · Redis
- MessagingKafka · RabbitMQ · Spring Integration · Axon
- TestingJUnit 5 · Testcontainers · ArchUnit · Mockito · Gatling
- InfraAWS · GCP · Kubernetes · Docker · Datadog · Sentry
Engagement
Three ways
to work with us.
No hourly retainer that bills for "thinking time." Pick a lane that matches your stage; everything is fixed-quote or transparently rated.
DEDICATED TEAMmonthly
Hire dedicated Java engineers.
Embedded engineers in your Slack, your Linear, your standups. A scaled pod of senior Java engineers, augmenting your team. Pause, resize, end with 30 days' notice.
$5k / eng / mo
PER ENGINEER
- Same senior bar as fixed-scope
- Embedded in your team
- Founder-direct escalation
ENGAGEMENTcustom
Strategic Java partnership.
A long-term partner for product orgs that need both delivery and judgement — JVM program, migration roadmap, hiring help.
custom
PROCUREMENT-FRIENDLY
- Multi-quarter roadmap
- Architecture & hiring partner
- Procurement-friendly paper
FAQ
Sharp questions,
straight answers.
Spring Boot vs Quarkus, Java 8 migrations, microservices — the questions we get on every Java discovery call.Spring Boot for most production systems — the ecosystem, documentation, and hiring pool are unmatched. Quarkus when native compilation and startup time are hard requirements, specifically serverless and CLI tools. Micronaut for compile-time DI in constrained environments. For 90% of enterprise backends, Spring Boot 3 is the right answer.
Yes. We migrate module by module behind a gateway. Java 21 services go live while Java 8 serves everything else. Kill-switch on every cutover. Your team ships throughout.
A modular monolith with clear bounded contexts handles most products and costs a fraction to operate. Microservices earn their place when independent deployment cadences are the actual bottleneck — not when the architecture diagram needs more boxes.
Yes. The engineers who write the RFC ship the code. No mid-engagement handoff. Direct access throughout.
Yes. We adapt to what's there and flag in the RFC where changes would materially reduce risk. If your setup works, we build on top of it.
Founder-direct
Tell us whatyou're building.
Thirty minutes with the founder. We'll bring a senior Java engineer, the relevant playbook, and a candid read on whether the JVM is the right runtime — or whether you're paying for ceremony you don't need.