Starbridge Engineering Labs: Making Java Cool Again

Join the team making Java and Kotlin cool again. Starbridge engineers are redefining what modern JVM systems can do.

Yakiv Yereskovskyi

Head of Engineering

At Starbridge, our core backend is written in Kotlin: a modern language built on the Java Virtual Machine (JVM). That decision wasn’t just about syntax sugar or developer ergonomics. It was about making a bet on one of the deepest, most capable, yet strangely under-tapped engineering ecosystems in the world.

In short: we’re making Java cool again.

The Global JVM Talent Pool

When you zoom out at the global engineering landscape, a few things become clear:

Top 3 Ecosystem by Demand: After JavaScript and Python, the JVM ecosystem (Java, Kotlin, Scala, Clojure, etc.) is the third most in-demand family of languages worldwide.
Massive Installed Base: Decades of enterprise systems, banking platforms, telecom networks, and backend services are powered by Java. The ecosystem is mature, widely taught, and globally distributed.
Incredible Depth: Unlike newer languages where senior talent is scarce, the JVM world has a huge bench of experienced engineers who’ve scaled complex systems for years.

And yet, something interesting has happened.

The Paradox: Big Talent, Underserved in Startups

Most newer high-growth startups default to Python, Node.js/TypeScript, or Go. These choices are seen as “modern” and often favored for speed of iteration pre-MVP.

That means a paradox emerges:

On one hand, there’s a huge, motivated JVM talent pool with engineers who are not only highly skilled but also eager to join fast-moving environments.
On the other hand, very few startups are actually recruiting them, leaving an isolated ecosystem of world-class engineers “on the outside looking in” when it comes to high-growth companies.

At Starbridge, we see this as an opportunity: recruit the best from a massive, under-leveraged pool of talent that want in on AI.

Build Slow, Scale Fast

One of the myths around Java (and by extension Kotlin) is that it’s “slower” to build compared to scripting languages. And, we concede, that’s actually true:

Pre-MVP tradeoff: You may move slightly slower in the earliest stages.
Post-MVP reality: Once you hit scale, JVM languages shine. Systems built on Kotlin/Java tend to be far easier to scale, optimize, and harden for reliability.

In other words: startups using dynamic languages sprint at first, then hit scaling headaches. We accept a little more discipline up front for huge speed-ups later.

This is exactly the tradeoff that companies like Twitter, LinkedIn, and Square faced in earlier waves, rewriting from Ruby/PHP into JVM-based backends once they needed reliability at scale. At Starbridge, we decided to start there from day one.

Luckily - we hit scale pretty fast, going from <10-150+ enterprise customers in under six months.

An Ode to Java (and Kotlin)

Java, JVM. Java or Kotlin are just programming languages that enable JVM usage for us. So why do we like JVM?

The most well known advantage of JVM - it is amazing with CPU intensive workload. It has an efficient concurrency model and native multicore support. As an application that has a huge volume of data processing we need a ton of CPU capacity - and Kotlin has amazing throughput. We love features such as optimal garbage collectors, dynamic optimizations, lock-free data structures and zero-copy streams.

Here’s an example of a problem that Kotlin was incredibly well suited to solve. At the center of the Starbridge application is what we call Bridges. Bridges are AI tables that enable business users to create AI agents in a spreadsheet type of view - you can add web agents, pull from our database or run analysis over columns. The throughput of the system can be insane, many customers have tables with 50k rows & 20 columns. Kotlin is incredibly well suited for this problem.

Perhaps the least intuitive advantage is that Kotlin is amazing with IO intensive workloads. The JVM memory model efficiently shares heap memory between core allowing less granular batching strategies that reduce data enrichment overhead and support of non-blocking socket and file operations. For us this means better scraping and file processing.

And last but not least: libraries and tooling in the JVM ecosystem are incredible. You can easily use libraries from Java, Kotlin, Scala, Closure, Groovy. IDE support is fantastic and Jetbrains has done a fantastic job with the quality of tooling for development. Amazing profilers and flight recorders, tools for observability, debuggers with hot code reload, static and dynamic analysis, telemetry and more.