// technology stack

The LIRA technology stack

A communication quality control platform. A multi-platform product with a shared design code: web and mobile apps, custom services on .NET, Node.js and Python, and cloud infrastructure.

Showcase

The stack at a glance

The key technologies of every layer — from the multi-platform showcase to custom services and cloud infrastructure.

Web

React + Next.js

A modern web interface built on App Router and React Server Components.

Mobile

Expo + React Native

A cross-platform app for iOS and Android.

UI Kit

HeroUI + Tailwind CSS

A unified design kit for web and mobile, with accessibility on top of React Aria.

Backend

.NET + ASP.NET Core

DDD microservices in C# with GraphQL federation via HotChocolate Fusion.

Backend

NestJS + tRPC + Fastify

Type-safe Node services with end-to-end contracts.

Data

PostgreSQL + pgvector

The primary database with vector search and embedding storage.

Infra

Kubernetes (k3s) + Argo CD

GitOps deployment on Yandex Cloud.

Foundation

TypeScript + Bun

Strict typing and a unified development toolchain.

Architecture

How it all fits together

Five layers — from the showcase to infrastructure — connected by shared contracts, GraphQL federation and cloud deployment on Kubernetes.

01Showcase

Next.js · ReactExpo · React NativeHeroUI · Tailwind CSS

02API & Backend

.NET · HotChocolate FusionNestJS · tRPC · FastifyYARP · GraphQL

03Custom development

Python · FastAPIML inferenceData processing

04Data & events

PostgreSQL · pgvectorRabbitMQ · MassTransitS3 Object Storage

05Infrastructure

k3s · Argo CDYandex Cloud · TerraformGrafana · Prometheus

Architecture in one paragraph

LIRA is a multi-platform product that brings together web, mobile apps and server-side services. The business logic is split across DDD microservices on two platforms: a .NET core with GraphQL federation via HotChocolate Fusion behind a single gateway, and Node.js services on NestJS with tRPC, plus dedicated Python services for non-standard data-processing tasks. Everything is rolled out the GitOps way: automatic deployment to a multi-cluster Kubernetes on Yandex Cloud. Data lives in PostgreSQL with the pgvector extension for vector search, events flow through a message queue, and monitoring and logs are handled by the Grafana stack.

01 · 8 technologies

Frontend · Web

A web app on Next.js and React: UI on HeroUI over Tailwind, data via Apollo/GraphQL and TanStack Query, built with Bun.

TypeScriptThe main language, strict + ts-reset, GraphQL codegen types

Next.jsApp Router, RSC, Turbopack, standalone output

ReactUI library (new JSX transform)

HeroUIThe main UI kit (compound components on React Aria)

Tailwind CSSUtility CSS, HeroUI design tokens, layout

Apollo ClientGraphQL client for the main API

GraphQLQuery language for the main API, codegen source

TanStack QueryServer state for REST services

02 · 8 technologies

Mobile

A cross-platform app on Expo and React Native with Expo Router navigation, UI on HeroUI Native over Uniwind.

Expo SDKBase runtime and toolchain (managed workflow, EAS)

React NativeCross-platform native UI framework (iOS/Android)

Expo RouterFile-based navigation with typed routes

HeroUI NativeThe main UI kit of components (web parity)

UniwindTailwind CSS v4 runtime for React Native

TanStack QueryCaching and fetching of REST data over native fetch

Apollo ClientGraphQL client for the main domains (Gateway Fusion)

EASApp build and submission

03 · 8 technologies

Backend · .NET

DDD microservices (CuratorPro) in C# and .NET: GraphQL federation via HotChocolate Fusion behind a YARP gateway, events via MassTransit and RabbitMQ.

C#The main language of all CuratorPro backend services

.NETThe target framework for all projects

ASP.NET CoreHTTP stack, hosting, DI, middleware

HotChocolate FusionFederated GraphQL gateway (public POST /graphql)

Entity Framework CoreORM, migrations per DbContext per schema

PostgreSQLA single database, schema-per-BC isolation

MassTransitDomain event bus + EF Core outbox/inbox

RabbitMQMessage broker transport under MassTransit

04 · 7 technologies

Backend · Node.js

Services on NestJS and Fastify with tRPC as the single API protocol and Prisma over PostgreSQL; the production runtime is Bun.

TypeScriptThe main language of all services, strict + NodeNext

BunPackage manager, dev server and production runtime

NestJSApplication framework for all services

FastifyHTTP server under the NestJS adapter

tRPCThe single API protocol for all Node services

PrismaORM (TS-native engine), output to src/generated/prisma

PostgreSQLPer-service logical database

05 · 6 technologies

Custom development

Dedicated Python services for non-standard tasks: data processing and analysis, ML inference and integrations; FastAPI, storage in PostgreSQL and S3.

PythonThe main language of data processing and analysis services

FastAPIHTTP API for data ingestion and processing

PyTorchML model inference runtime (CUDA + CPU)

ONNX RuntimeInference of pre-trained ML models

PostgreSQLData storage for services

S3 (Yandex Object Storage)Object storage for files and artifacts

06 · 10 technologies

Infrastructure & DevOps

A GitOps platform on Yandex Cloud: a multi-cluster k3s managed by Argo CD, Terraform provisioning and monitoring on the Grafana stack.

k3sLightweight Kubernetes; three clusters (mgmt + prod + dev) on VMs

Argo CDGitOps engine: ApplicationSet, sync waves, ServerSideApply

TerraformIaC for the prod environment (k3s VMs, network, IAM)

Yandex CloudCloud provider (compute, VPC, IAM, Registry, Lockbox)

CloudNativePG (CNPG)Kubernetes PostgreSQL operator

TraefikIngress controller / reverse proxy

PrometheusMetrics collection and alerting, federated remote_write

GrafanaDashboards and visualization of metrics/logs/traces

DockerContainerization of all services + Compose stack for dev/stage

GitHub ActionsCI/CD pipelines (20 workflows: build, promote, release)

07 · 9 technologies

Development tooling

Centralized development tooling: a single package manager (Bun), Husky git hooks, commitlint and shared Prettier and ESLint configs.

BunThe single package manager and runtime of the project

HuskyGit hooks at the repo root (pre-commit, commit-msg)

commitlintEnforces Conventional Commits in the commit-msg hook

PrettierFormatter with import sorting + Tailwind class sort

ESLintUnified lint rules and DDD module boundaries

TypeScriptStrict typing across all project packages

Conventional CommitsA single convention for commit messages

RenovateAutomated dependency updates with grouping

Node.jsThe target runtime for production builds