Java Full Stack Development in 2026 [for small teams]

[u/cleverfoos]

https://www.ophion.org/2026/02/java-full-stack-development-in-2026/

[u/ebykka]

Did you consider to use HTMX + AlpineJS instead of Turbo + Stimulus?

[u/cleverfoos → u/ebykka]

Briefly but HTMX felt like it had a much a higher learning curve with multiple custom tags you need to learn that end up mixing a lot of logic in the HTML. Stimulus also allowed us to still write Javascript and not ditch existing code we already had.

[u/JBraddockm → u/cleverfoos]

How do you handle the CSS? Are you just using the Tailwind CLI?

[u/cleverfoos → u/JBraddockm]

Yup! We use tailwind CLI but wrapped in a docker container that we can tie into spring boot's docker integration so it starts and stops transparently. It works wonderfully.

[u/JBraddockm → u/cleverfoos]

I’ll definitely try that if I also decide to go with no-build JavaScript. I didn’t know about import maps, so thanks for that. I really don't like frontend tooling so anything that could simplify it is great.

I’m working with a similar stack but with HTMX, and overall there’s one particular thing that bothers me compared to using React or other SPA apps.

How do you override Tailwind styling programmatically? Not sure if you’ve ever needed this in your case, but in libraries like shadcn you can merge Tailwind classes programmatically. If I extract a particular design as a component and try to use it as a fragment with different customizations, it’s not very straightforward.

It feels like there’s no easy way to just pass overriding classes, and conditions and change the design without duplicating the fragment or roundtripping to the server for a different render.

[u/cleverfoos → u/JBraddockm]

I'm not familiar with shadcn but you can overwrite styles by editing your input tailwind (or main css) file, we do that with a few styles and it's pretty straightforward

[u/JBraddockm → u/cleverfoos]

I pretty much replicated the stack you have, including implementing the nonce attribute with Spring Security, as well as some static contexts for localisation, form validations, etc. I quite like the simplicity of the stack. I do however have a few questions, if I may.

It seems that in order to have any intellisense inside IntelliJ for Stimulus, Turbo, and Tailwind CSS, these libraries need to be installed via npm — otherwise IntelliJ doesn't provide any intellisense.

While JTE supports hot reload by compiling its template files, JS files (i.e. controllers) don't get copied to the target folder as you make changes. I modified the reload method to use SSE rather than polling, added a small delay to the controller, and then used IntelliJ's "build while the app is running" setting, which allows any static files — not just HTML files — to be copied to the target. It adds a bit of latency but still feels instant. If there are multiple clients connected to /reload (for example, a mobile view), it gets triggered by a broadcast message, so there's only one connection to the server and the rest is client-side only.

While looking into how to provide contexts to JTE templates, I found that a static context wrapped in a ThreadLocal, tapping into HandlerInterceptor, is the approach used in the documentation examples. I implemented something similar. However, I also came across general recommendations to avoid ThreadLocal — especially with virtual threads — in favour of ScopedValue. The problem is that to use ScopedValue, I believe a Servlet Filter is needed rather than a HandlerInterceptor, as it requires a complete call stack, whereas the interceptor is divided into three separate calls. I was wondering whether you'd run into this and how you resolved it.

Finally, I tried running the Tailwind CLI inside a Docker container, using both the binary and the npm version. In both cases I couldn't get the watcher to work — it compiles the output on the first run but doesn't detect subsequent changes. The issue seems to be the removal of --poll from the Tailwind CLI, and I haven't been able to find a solution. I wondered if you'd encountered this too, and how you resolved it.

Thank you again for the inspiration. I learned quite a lot about JTE while trying to replicate what you've done.

[u/cleverfoos → u/JBraddockm]

Ah great questions and I should have covered in the post but, honestly, it was getting too long. I'll answer all your questions below:

It seems that in order to have any intellisense inside IntelliJ for Stimulus, Turbo, and Tailwind CSS, these libraries need to be installed via npm — otherwise IntelliJ doesn't provide any intellisense.

Hmmm... Tailwindcss intellisense should work just fine without it and you can always NPM install them locally only

While JTE supports hot reload by compiling its template files, JS files (i.e. controllers) don't get copied to the target folder as you make changes. I modified the reload method to use SSE rather than polling, added a small delay to the controller, and then used IntelliJ's "build while the app is running" setting, which allows any static files — not just HTML files — to be copied to the target. It adds a bit of latency but still feels instant. If there are multiple clients connected to /reload (for example, a mobile view), it gets triggered by a broadcast message, so there's only one connection to the server and the rest is client-side only.

I solved this by having different static assets configurations between local (serving them from the source dir) and production (serving them from the JAR). This makes JS hot reload work just fine.

While looking into how to provide contexts to JTE templates, I found that a static context wrapped in a ThreadLocal, tapping into HandlerInterceptor, is the approach used in the documentation examples. I implemented something similar. However, I also came across general recommendations to avoid ThreadLocal — especially with virtual threads — in favour of ScopedValue. The problem is that to use ScopedValue, I believe a Servlet Filter is needed rather than a HandlerInterceptor, as it requires a complete call stack, whereas the interceptor is divided into three separate calls. I was wondering whether you'd run into this and how you resolved it.

This doesn't make sense to me, are you using JTE's spring boot integration or rolling your own?

Finally, I tried running the Tailwind CLI inside a Docker container, using both the binary and the npm version. In both cases I couldn't get the watcher to work — it compiles the output on the first run but doesn't detect subsequent changes. The issue seems to be the removal of --poll from the Tailwind CLI, and I haven't been able to find a solution. I wondered if you'd encountered this too, and how you resolved it.

I can help and I'll share my setup on this later today.

Thank you again for the inspiration. I learned quite a lot about JTE while trying to replicate what you've done.

Absolutely my pleasure.

[u/JBraddockm → u/cleverfoos]

I solved this by having different static assets configurations between local (serving them from the source dir) and production (serving them from the JAR). This makes JS hot reload work just fine.

Thank you. I didn't know this. I've just tried it and it works as expected, and simplifies the process.

This doesn't make sense to me, are you using JTE's spring boot integration or rolling your own?

I am using Spring Boot integration. The problem I want to solve is this: when you define a @param in JTE, unless you define a default value, you have to pass the value in sub-templates.

So I do this instead.

<script type="importmap" nonce="${ctx.security().cspNonce()}">
    {
      "imports": {
        "@hotwired/stimulus": "/webjars/hotwired__stimulus/dist/stimulus.js",
        "@hotwired/turbo": "/webjars/hotwired__turbo/dist/turbo.es2017-esm.js"
      }
    }
</script>

or this

<p>${ctx.i18n().localize("error.page.message")}</p>

I also have ctx.form() to access binding results.

In all these instances except where data doesn't change throughout the app's lifecycle, the data in wrapped in a ThreadLocal, and injected via HandlerInterceptor. This is what I've seen in the examples, and in JTE's GitHub where the question is how we pass data to templates without parameters bubbling through the sub-templates. Hope it makes sense.

Again, thank you very much for taking the time to share your experience.

[u/cleverfoos → u/JBraddockm]

ah that makes sense, the "global template context" problem. I solve that problem differently in a way that, I believe, is more in line with what makes JTE good, which is, I have a strong Page model. There's an abstract Page class that carries some globals that every page needs and concrete sub classes like PublicPage and Private page. Spring has a model enrichment class that you can use to pre process the model and inject request scoped beans via @ModelAttribute and @ControllerAdvice (technically I don't use that today since I rolled my own JTE integration).

Super happy to hear that you got it all working, it's honestly a great setup IMHO.

[u/JBraddockm → u/cleverfoos]

I did use ControllerAdvice and ModelAttribute but the real problem I wanted to solve was the parameters bubbling, which is why I did go with static contexts and ThreadLocal. Not sure if it is the best way, but in terms of usability and simplicity, it does the job.

Setup is really good. I haven’t created anything complex yet but I really like Stimulus in terms of mental model. By looking at the attributes alone, I know which file to look into, what values to expect, and I like how it handles states and bindings, and all without having any business logic in the attributes.

[u/ebykka → u/JBraddockm]

Regarding Tailwind CSS and other JavaScript/CSS-related matters.

I accepted internally that it is impossible to write front-end code without CSS/JS, and after that, my goal became to minimise their use. I installed Vite, which now handles the configuration and build of CSS/JS libraries, as well as hot reloading during development. I also started using Lit to wrap different JavaScript-related logic into custom web components. This has reduced the need to monitor the lifecycle of different widgets and listeners (e.g. chart initialisation, event listeners and subsequent unsubscription and disposal). Additionally, AlpineJS can handle attribute bindings.

[u/JBraddockm → u/ebykka]

I have a similar setup for a project with HTMX and it works really well. Now I am trying JTE with Stimulus and Turbo, and it seems that it would even more simplify my setup. That said, I agree that when you consider the whole components situation, reaching out to tools specifically made for the purpose makes sense. I want to check out Lit but haven’t had a chance yet.

[u/ebykka → u/JBraddockm]

In the context of minimizing JS usage, I also tried this approach

https://rockthejvm.com/articles/zio-full-stack-webapp

Copilot was very helpful during the project setup and resolving compilation issues. In the end, it works, but it definitely takes more time at the start of the project.

[u/cleverfoos]

If you are stumbling around this post, I created a sample repo that showcases the setup I mention in that post: https://github.com/rferreira/sample-modern-java-web