Hello World — We're JT Digital

This is our first blog post, so let's start with who we are and how we think about building software.

JT Digital is a software studio based in Slovenia. We build web applications for clients and develop our own tools and products. We'll write more about those in future posts — today, we want to talk about what drives our work.

We care about the craft

There's a version of software development where you grab the most popular framework, follow the tutorial, glue things together, and ship. It works. Plenty of successful products are built that way.

That's not how we work.

We believe every technical decision should be intentional. Not clever for the sake of clever — intentional. The right tool for the job, the right amount of complexity for the problem, the right abstraction at the right time.

This means we spend time understanding a problem before writing code. We think about how a codebase will feel to work in six months from now. We care about type safety not as a checkbox, but because it catches real bugs before users do.

What this looks like in practice

We recently built GZS Inovacije — a platform for the Chamber of Commerce and Industry of Slovenia that manages their national innovation awards process.

The platform handles the full cycle: companies submit innovations, judges evaluate them at regional and national levels using weighted criteria, and the best projects receive Gold, Silver, and Bronze recognition. 13 regions, dozens of judges, hundreds of projects — all on one system that replaced what used to be spreadsheets and email chains.

The admin dashboard — a single overview of all projects, judges, and system settings across 13 regions.

The company portal — where businesses submit their innovations and track progress.

The evaluation form — judges score innovations against weighted criteria at regional and national levels.

For this project, we chose server-side rendering with Fastify, TypeScript, and HTMX. We build HTML on the server using fluent-html — a library we developed ourselves — where every component is a plain TypeScript function with full type safety:

function ProjectCard({ name, company, category }: ProjectCardProps): View {
  return Div(
    H3(name).fontWeight("bold").textSize("lg"),
    P(company).textColor("gray-600"),
    Badge(category)
  ).padding("4").border().rounded("lg");
}

No template language to learn. No client-side runtime to ship. Your IDE understands everything — autocomplete, refactoring, go-to-definition — because it's just TypeScript.

When the page needs to update without a full reload — filtering a list, submitting a score — HTMX handles it by swapping in server-rendered HTML. The server stays the single source of truth. The client stays thin.

The result: a single TypeScript codebase, one deployment, fast page loads, and a mental model that's easy to reason about. Request comes in, query the database, build HTML, send it back.

Why we're writing about this

Not to market ourselves — we have enough work. We're writing because we think there are ideas worth sharing.

Ideas like: you don't always need the heaviest tools to solve a problem. Type safety is worth the investment. Server-rendered HTML is underrated. Building your own tools, when done thoughtfully, gives you leverage that off-the-shelf solutions can't match.

We'll be writing about these topics in future posts — the technical decisions behind our projects, the tools we're building, and the lessons we're learning along the way.

If any of this resonates, follow along. We're just getting started.