Engineering cases

Architecture,
not a list of technologies.

Some of these are closed client code: I show the architecture, the decisions and small code fragments rather than the whole repository. Where the code is open, there is a GitHub link.

Closed source

Manufacturing ERP systems

Two independent implementations: steel structures (metalstruct) and woodworking (manufacture) — from order to shipping.

Order

Design

Material procurement

Production

Quality control

Warehouse

Shipping / installation

Up to 7 roles with different access scope (director, design engineer, process engineer, production manager, site foreman, procurement) and a multi-stage production cycle for a spec — from contract to installation, including warranty returns. manufacture adds multi-tenancy and in-app docx/xlsx editing via OnlyOffice Document Server, with self-hosted infrastructure on Supabase (PostgreSQL + PostgREST + Auth + Storage + Edge Functions).

Both systems were built and put into production at clients — they didn't stay pilots.

permissions.ts — role-based access (metalstruct)

export type OrgRole =
  | "director" | "manager" | "head_constructor"
  | "constructor" | "supply_manager" | "production_head" | "foreman";

export function hasRole(memberRoles: string[], ...required: OrgRole[]): boolean {
  return required.some((r) => memberRoles.includes(r));
}

/**
 * director, manager — full access
 * head_constructor — all specs at design stages
 * supply_manager — all specs (procurement handling)
 * production_head, foreman — all specs (production/warehouse)
 * constructor — only assigned specs
 */
export function canSeeAllSpecs(roles: string[]): boolean {
  return hasRole(roles, "director", "manager", "head_constructor",
    "supply_manager", "production_head", "foreman");
}

Fastify 5Next.jsPostgreSQLDrizzle ORMSupabaseOnlyOffice

Closed source

Voice AI assistants for call centers

Three verticals (tire service, pawnshop, tech support) on one architectural base.

Call (Asterisk AudioSocket)

SpeechKit Realtime STT

Dialog state machine

SpeechKit TTS

CRM (Bitrix24)

Yandex SpeechKit Realtime (speech-to-speech WebSocket) + Asterisk PBX (AudioSocket/ARI) for three business lines: appointment booking and tire reservation (“KOLESITI”), branch navigation and remote collateral valuation (“Moscow City Pawnshop”), ticket creation and status checks (“Entersite”). The dialog runs on a finite state machine — not just a chain of LLM prompts, but a predictable flow with explicit transitions.

Bitrix24 and Yandex Maps integration for geolocating branches.

state_manager.py — dialog finite state machine (tire_assistant_rev2)

class DialogState(Enum):
    GREETING = "greeting"
    SELECT_CENTER = "select_center"
    SELECT_DATE = "select_date"
    SELECT_SERVICE = "select_service"
    COLLECT_PHONE = "collect_phone"
    CONFIRM_BOOKING = "confirm_booking"
    UPSELL = "upsell"
    CANCEL = "cancel"
    FAREWELL = "farewell"

class StateManager:
    def transition(self, new_state: DialogState):
        if self.session:
            old = self.session.state
            self.session.state = new_state
            logger.info(f"State: {old.value} -> {new_state.value}")

Yandex SpeechKit RealtimeAsterisk (AudioSocket/ARI)PythonBitrix24State machine

Closed source

Audio Dialog Analyzer

Transcription and LLM scoring of cashier–customer dialogs for retail sales-quality control.

Call audio

Whisper / SpeechKit STT

Diarization (pyannote.audio)

LLM script scoring (Ollama)

Dialog-path visualization

Production domain cashear.ru. Pipeline: speech recognition → speaker diarization (splitting cashier/customer) → LLM scoring against the sales script → “sales flow” visualization for service-quality control. Self-hosted Supabase as the main data platform.

Whisper large-v3pyannote.audioOllama (qwen2.5)FastAPINext.js

Open source

Tender Status Tracker

A FastAPI service with a state machine and a tender status audit trail — open source, tests on real Postgres.

$Tender Status Tracker Swagger UI: the GET /tenders/{tender_id}/history endpoint with a real response — the full status-change history of a tender$

The data model splits the tender and its status-change history into separate tables (not a JSON field), so you can efficiently aggregate “who changes statuses most often” without parsing. Status transitions are an explicit state machine (Draft → Active → Won/Lost); terminal statuses aren't overwritten through the normal path. A reason for the status change is required at the Pydantic schema level.

Covered by 10 tests on real PostgreSQL in Docker: the full lifecycle, rejection of invalid transitions, 404/422 cases. The screenshot shows the GET /tenders/{tender_id}/history endpoint of the service running locally in Docker: the full chain of status changes for one tender, with who changed it and why.

FastAPIPostgreSQLSQLAlchemy 2.0RedisDocker ComposeCI

GitHub →

Open source

Tender DB Schema

Database schema design for a tender platform, plus analytical SQL queries on top of it.

A schema deliberately separate from tender-status-tracker: there, statuses describe a tender's lifecycle from the platform's point of view (draft/active/closed/cancelled); here, from a specific bidder's point of view. Mixing two bounded contexts in one table for the sake of formal reuse would be an artificial choice. Analytical queries (top companies by won amount, average discount by category) and tests on real Postgres are in the repository.

PostgreSQLSQLSchema designpytest

GitHub →

Live demo

Skeet Log

An offline-first PWA for tracking skeet-shooting practice — deployed and used in the field.

An offline-first PWA on top of IndexedDB and a Service Worker — it works with no connection right at the range and syncs once a connection is available. Visualization of a 25-target round by stand position, trend statistics over different periods. Self-hosted production deploy on better-auth/Express/PostgreSQL.

PWAService WorkerIndexedDBTypeScriptExpressDrizzlePostgreSQL

skeet-log.ru →

Closed source

TonConnect protocol reverse engineering

Decrypting bridge messages between a dApp and a wallet by hand via NaCl box decryption.

TonConnect is the protocol that connects TON wallets to a dApp through a bridge server. Instead of using a ready-made SDK as a black box, I implemented the bridge-message decryption by hand: recovering the wallet's secret key, NaCl box decryption (nonce + encrypted body), and parsing the resulting payload. This is a level below the usual REST API — you need to understand how the protocol's end-to-end encryption works, not just call an SDK method.

wallet.service.ts — decrypting a bridge message

this.box_key_pair = nacl.box.keyPair.fromSecretKey(secretKeyBytes);

const nonce = bodyBytes.slice(0, nacl.box.nonceLength);
const message = bodyBytes.slice(nacl.box.nonceLength);

const opened = nacl.box.open(
  message,
  nonce,
  theirPublicKeyBytes,
  this.box_key_pair.secretKey
);

const payload = JSON.parse(Buffer.from(opened).toString());

TypeScriptNaCl / tweetnaclTONProtocol reverse engineering

Closed source

Browser automation at scale

Anti-bot-resistant clients for a distributed system of many parallel sessions.

Building browser-automation clients resistant to anti-bot protection: network-traffic interception (including decrypting encrypted bridge messages between the app and the wallet, see the TonConnect case above), client-environment emulation, crypto-wallet integration (TON, Solana) — for a distributed system of many parallel browser sessions. Stable parallel operation was maintained at a scale of up to 40,000 concurrent sessions.

PlaywrightPatchrightNetwork interceptionMulti-session architecture

Closed source

FlashArbExecutor.sol

A Solidity contract for atomic arbitrage via Aave V3 flash loans on Base.

The contract takes a flash loan from Aave V3, runs a chain of swaps through Uniswap V3 / SushiSwap V3 / BaseSwap V3 / Aerodrome V2/CL, and checks that the amount received covers the debt plus a minimum profit threshold — otherwise the whole transaction reverts, atomically. Security patterns: a reentrancy guard on the entry point, a flash-loan callback that only accepts calls from the Aave Pool, an emergency pause, and owner-only admin functions.

To be clear: the contract is designed and implemented, but not deployed to mainnet — it was never run in production.

FlashArbExecutor.sol — the flash-loan callback

function executeOperation(
    address asset, uint256 amount, uint256 premium,
    address initiator, bytes calldata params
) external override returns (bool) {
    require(msg.sender == address(AAVE_POOL), "Caller not Aave Pool");
    require(initiator == address(this), "Initiator not self");

    SwapStep[] memory steps = abi.decode(params, (SwapStep[]));

    uint256 currentAmount = amount;
    for (uint256 i = 0; i < steps.length; i++) {
        currentAmount = _executeSwap(steps[i], currentAmount);
    }

    uint256 totalOwed = amount + premium;
    require(currentAmount >= totalOwed + minProfit, "Insufficient profit");
    ...
}

SolidityAave V3Flash loansUniswap V3Reentrancy guard

Closed source

cadroid — offline CAD on Android

The SolveSpace parametric 3D solver in C++, embedded into Android via NDK/JNI, with a Three.js web frontend.

React + Three.js — 3D/2D viewport (Viewport3D, Sketch2D)

WebSocket ws://localhost:8080/ws

Kotlin + Ktor — on-device WebSocket server

JNI (SolveSpaceJNI.kt / slvs_jni.cpp)

SolveSpace C++ solver, built with the Android NDK → libcadcore.so

The upstream SolveSpace geometric solver (C++, including Eigen, mimalloc) is built with the Android NDK into a native library, accessed from Kotlin over a JNI bridge. On top of that, Ktor runs a WebSocket server right on the device, which a React + Three.js web frontend connects to for 2D/3D sketch editing and STL export. There are separate test_jvm/test_desktop environments for exercising the solver without building an APK.

A local pet project, not deployed or published anywhere — this is an architecture description only.

C++Android NDK / JNIKotlinKtorReactThree.js

Closed source

WAX/EOS blockchain game

Crypto-wallet auth, crafting/market/staking modules, a PixiJS map.

About a year of active development on a team: WAX wallet auth (UAL), game modules Craft / Market / Woodwork / Inventory / Hunt / Bank / Staking / Mining, an interactive PixiJS map with viewport navigation. Not a tutorial — an attempt at a full product, over 100 commits on the project.

ReactRedux ToolkitPixiJS@eosdacio/ual-waxeosjs

Closed source

An MCP tool for LLM orchestration

Delegating part of the work between Claude and DeepSeek through a custom MCP server.

An experimental MCP server through which Claude Code can delegate part of a review or a task to DeepSeek — infrastructure for multi-LLM orchestration rather than just using an off-the-shelf chat interface. Part of a broader pattern: building my own AI tools for my workflow (see also a userscript that converts a GitLab MR to markdown for LLM review).

MCPPythonLLM orchestration

Let's talk about your project

@gof2706 →

Architecture,not a list of technologies.

Manufacturing ERP systems

Voice AI assistants for call centers

Audio Dialog Analyzer

Tender Status Tracker

Tender DB Schema

Skeet Log

TonConnect protocol reverse engineering

Browser automation at scale

FlashArbExecutor.sol

cadroid — offline CAD on Android

WAX/EOS blockchain game

An MCP tool for LLM orchestration

Let's talk about your project

Architecture,
not a list of technologies.