Technologies

We don't chase trends; we use a stack proven across our products that works well together: .NET 9 and PostgreSQL on the backend, Next.js and Angular on the web, Flutter on mobile, native Windows on the desktop.

Talk to an expert

We don't chase trendy technology; we use a stack that works well together

While building our sector products, we didn't try a different technology on every project; instead we used the same stack again and again, one we've repeatedly confirmed works well together: .NET 9 and PostgreSQL on the backend, Next.js on the public web, Angular on the admin panel, Flutter on mobile, native Windows on the desktop. This isn't a habit — it's a discipline. Every new project starts on a proven foundation, not a from-scratch technology debate.

The proof of this stack isn't far away: the vosetu.com you're browsing right now is built on the Next.js (public) + Angular (admin panel) pair, on top of a .NET 9 Web API. The stack we talk about isn't a slide — it's the site beneath you.

A stack validated again and again across our product family
A core of .NET 9, Next.js, Angular, Flutter, PostgreSQL
This site itself is built on the same stack — we dogfood it
One right tool per layer — no scattered choices

Figures on a raised platform have lifted a hatch in the floor and are looking down; the mechanism running beneath their feet is identical to the machine displayed on the pedestal beside them — The stack we describe is the one running under the site you're standing on.

The core: backend and data

Backend

.NET 9
ASP.NET Web API
Layered architecture (service/bll/dal)

Database

PostgreSQL
Redis
PostGIS

Identity & security

JWT
OAuth2/OIDC
HMAC
mTLS

Clarity in technology choice

One tool per layer

Every layer has its own right tool, and once we pick it we close the debate: Next.js for the public side, Angular for the admin panel, PostgreSQL for data. We don't keep five different libraries around that do the same job — that only grows the learning curve and the maintenance cost.

One stable choice per layer
Learning and maintenance overhead stays small

A workshop tool wall where each painted silhouette holds exactly one tool and no silhouette is doubled; a figure on a ladder returns a tool to its own outline while a second figure beside them closes the lid of a crate full of surplus duplicates

We don't chase microservice hype

Putting ten separate services behind one screen makes a small-to-medium product unmanageable. We start with a layered, single-deployment-unit (monolithic) architecture; we split it only when a real scaling need arises — not because it might theoretically be needed.

We start with a layered, single-deployment-unit architecture
The decision to split is driven by real need

Two figures wheel one single solid block in on a cart and set it down whole; faint pre-scored lines across its surface show where it could later be split, and the saw hanging on the hook behind them has not been touched

We put it under load before it enters the stack

We don't add a technology to the stack off a landing page or a comparison table. First we build something real with it: a small but complete piece is written, pushed under load, and what its upkeep costs becomes visible. The decision comes out of that trial; if it doesn't hold, it never enters the stack — and nobody has to find that out in production.

The decision comes from a loaded trial, not a slide
Upkeep cost is measured before the choice

A machine bolted to a test bed turns under load; the teal disc weights hanging from its side arm have bent it, a figure on a step threads one more disc on while another feels the bearing with a hand, and behind them a row of the same machine is already at work in the finished line

Web: the public side and the admin panel

Public side

Next.js
TypeScript
Tailwind

Admin panel

Angular
TypeScript

Design

Figma

Mobile, desktop and hardware

Mobile

Flutter
single codebase

Desktop

Native Windows

Hardware & IoT

Modbus
OPC-UA
MQTT
TCP/IP

Why you can trust this stack

Proven across our product family

We're not talking theory — this is the real stack keeping our whole sector-product family running.

This site is built on the same stack

vosetu.com itself runs on the Next.js + Angular + .NET 9 trio; what you're seeing is an example, not a claim.

One team, one language, end to end

Backend, web, mobile and desktop are built by the same team under the same architectural principles — nothing gets lost in handoff.

The source code is yours

The delivered code, documentation and infrastructure definitions are yours; we place no restriction if you want to hand it to another team.

A tall rack where every shelf holds exactly one crate, each a different shape; two figures slide one crate out on rails and push a new one of the same shape into its place, while the rack itself does not move and the crates above and below stay untouched — Swapping a technology doesn't mean dismantling the rack — a new one of the same shape slides into its place.

Infrastructure, testing and real-time

Infrastructure

Docker
GitHub Actions
MinIO
RabbitMQ

Testing & quality

xUnit
Playwright
k6
JMeter

Real-time & notifications

WebSocket
SignalR
FCM

A finished machine stands alone on the left with its flywheel turning; on the long trestle in front of it the casting pattern for every one of its parts lies in its own place, and on the right one figure hands the shallow tray holding that whole set of patterns to a second figure loading it onto a handcart — What we hand over isn't only the running system — it's the full set of moulds you could recast it from.

Proven

Products built on this stack

Layered

service / bll / dal architecture

Published languages (RTL included)

.NET 9

Modern core stack

Let's determine together which layers fit your project

We'll listen to your need and map out together which pieces of this stack serve you. The first conversation is non-binding.