In healthcare technology, regulatory requirements don’t wait for your performance benchmarks to catch up. When the rules change — and they change fast — your system needs to filter, evaluate, and respond in milliseconds, not seconds. This is the story of how we stopped fighting Java’s limitations and started letting Rust do the heavy lifting.

The Problem

Our Spring Boot application was handling increasingly complex rule-based filtering logic driven by rapidly changing regulatory requirements. We looked at Drools — the go-to Java rules engine — but the learning curve and operational overhead made it a non-starter for our team under time pressure.

Pure Java implementations were getting slower with every new rule added. We needed something faster, and we needed it without spinning up an entirely separate microservice with all the network overhead that brings.

Enter Rust

Rust offers the raw computational speed of C with memory safety guarantees that make it practical for production systems. The question wasn’t whether Rust could solve the problem — it clearly could. The question was how to get Java and Rust talking to each other cleanly inside the same JVM process.

Here’s the architecture we landed on:

1. A Maven Java Library as the Bridge

We created a thin Maven library that acts as the interface layer between Spring Boot and the Rust code. This keeps the integration invisible to the rest of the application — from the outside, it’s just a regular Java dependency.

2. rust-maven-plugin for Cross-Architecture Compilation

The rust-maven-plugin handles compiling the Rust code as part of the standard Maven build lifecycle. This means the Rust binary is built automatically — no separate build step, no manual artifact management.

3. questdb’s jar-jni for Embedding

We used questdb’s jar-jni package to embed the compiled Rust shared library directly inside the JAR file. At runtime, the library is extracted and loaded transparently. Your deployment artifact is still a single JAR.

4. Spring Boot Integration via ResponseBodyAdvice

The rule engine hooks into Spring’s ResponseBodyAdvice to intercept and filter responses before they leave the application. This makes the filtering logic cross-cutting and consistent without polluting individual controllers.

5. Gorules’ Zen Engine for Rule Definitions

For the rules themselves, we used Gorules’ Zen engine — a JSON-based decision model system. Rules are defined as structured JSON, not code, which means compliance teams can reason about them and changes can be deployed without a full release cycle.

The Results

Performance improvements were dramatic. The Rust-backed engine handled complex filtering operations that previously caused measurable latency spikes with no perceptible overhead. We also validated the approach with vector embeddings using FastEmbed for semantic matching — Rust handles that workload without breaking a sweat.

Most importantly: no separate microservice. No extra network hop. No new service to monitor, scale, or debug. The Rust code lives in the JVM process.

The Warning You Need to Hear

Rust panics can bring down your JVM faster than mentioning ‘deprecated features’.

This is not a hypothetical. If your Rust code panics uncontrolled, it will take the JVM with it. You need deliberate error handling at the JNI boundary — catch panics in Rust, convert them to controlled exceptions, and let Java handle the failure gracefully. Do not skip this step.

The Broader Lesson

Java gives you the enterprise ecosystem: Spring, Hibernate, decades of library support, and a workforce that knows it. Rust gives you raw speed and memory safety where you need it most. These aren’t competing choices — they’re complementary ones.

Strategic language hybridization isn’t about rewriting everything in the fashionable language of the year. It’s about identifying the specific bottlenecks where a different tool changes the equation, and integrating it precisely there.

For us, that was regulatory rule filtering in a healthcare application. For you, it might be something else entirely. But the pattern holds: keep Java where Java excels, and let Rust handle the parts that need to go faster.

---

Originally published on LinkedIn Pulse.