Sajjad Servatjoo

Tejarat Shayan

Stack: Go، NestJS، TypeScript، Vue 3، React، PostgreSQL، Oracle، Redis، Kafka، RabbitMQ، Docker، Kubernetes، Microservices

Irancell (MTN Irancell)

Stack: TypeScript، Node.js، Vue، REST API

Hubwork

Stack: NestJS، Vue.js، Asterisk، VoIP، Node.js، MySQL

Consulting Engineers firm

Stack: PHP، Laravel، MySQL، JavaScript، CSS3، Linux، Networking

IT Department Manager — nine and a half years

Total ownership of the technology at a consulting-engineering firm: the team, the infrastructure, procurement, and the software I wrote myself. Management is not something I picked up recently; it is where my career started.

Technical Manager, Tejarat Shayan

Led the engineering team on a Bank Tejarat–affiliated financial system: prioritisation, code standards, review, and translating banking stakeholder demands into testable acceptance criteria.

Product definition, written down and defensible

Even in personal projects I write the document before the code. The Helios governance brief locks decisions, partitions ownership across fifteen domains with no overlap, and states explicitly which document wins in a conflict. That is precisely the job a product owner has to be able to do.

Decisions recorded with their cost

Every ADR in Social CMS carries a “what we gave up” section. When I locked the principle that tokens never leave the device, I wrote down its cost — scheduling on iOS cannot be guaranteed — and required the UI to say so. A stakeholder does not need a promise; they need an accurate picture of the trade they are making.

Scope with kill conditions

In research work I write down what result would stop the project before I start. The three market studies kept their negative findings, and those turned out to be the most valuable part of the report. Being able to say “this path is closed” early is what saves a team’s budget.

Bilingual, cross-cultural delivery

My project documentation is bilingual because its readers are. Azerbaijani is my mother tongue, Persian professional, Turkish and English working. I have worked with Iranian banking stakeholders and inside English-language codebases alike.

Fund platform — wallet ledger service

The ledger is the single source of truth; a balance is only a derived, continuously reconciled projection.

Live in production and under active maintenance and development. An immutable, double-entry financial ledger for Iranian Rial. The design law is explicit: financial correctness over development simplicity. The domain is pure with no I/O, the application layer holds the shared posting engine and idempotency, and infrastructure runs on pgx with hand-written parameterised SQL — no ORM. Three separate entry points: API, worker and reconciler.

• The balancing rule, sign convention and account-number/IBAN validation live in a pure domain — fully unit-tested.
• UUIDv5 idempotency with safe replay: the same request twice yields the same result and no second posting.
• An outbox dispatcher on SKIP LOCKED with exponential backoff, jitter and a dead-letter queue.
• A leader-elected reconciler that continuously checks integrity invariants and the audit chain, and maintains partitions.
• Transport middleware: TLS, IP allowlist, API key, rate limiting, request-id and request logging — with Prometheus metrics and an OpenAPI spec.
• A Vue 3 dashboard with TanStack Query/Table/Virtual, ECharts, a Jalali calendar, enforced architecture boundaries, accessibility tests and a bundle-size budget.

Stack: Go 1.26، PostgreSQL 16، Chi، pgx، Goose، Oracle CDC، Prometheus، Vue 3، TanStack، Tailwind، Playwright، Docker

Invoice & supply-chain platform

Fifteen services behind an auto-discovering gateway, each with its own microfrontend inside one shell.

Deployed and live in production, under active maintenance and development. A multi-service invoice platform: a BIAN-aligned invoice system-of-record behind an API gateway that discovers services automatically, with Vue microfrontends mounted into a single shell according to the user’s permissions. The edge owns IAM — users, roles, permissions, API keys and impersonation — and all outbound traffic passes through one chokepoint with a circuit breaker and redaction.

• Fifteen services: invoice, payment, payment-order, debtor, eligibility, fraud, signature, file, logs, egress, notifier, OTP, captcha and document conversion.
• Invoice workflows with VAT and settlement, integrated with the Moadian and Ofogh tax systems.
• API-log indexing, search and replay on OpenSearch; object storage on MinIO.
• A documented architectural decision to drop APISIX in favour of a purpose-built gateway — reasoned in writing as an ADR.

Stack: Go، Vue 3، Microfrontends، API Gateway، OpenSearch، MinIO، PostgreSQL، Docker، BIAN

Credit-scoring system

No external source is mandatory; a missing one does not stop the score, it lowers the stated confidence.

A standalone service that assesses an individual’s credit by national ID, on a scoring model with a 1000-point budget and a non-compensatory rule. The scoring engine is pure with no I/O and draws on five external sources. The key design decision: no source is mandatory — if one is unavailable the score is still issued, but the response states honestly which source was missing and how far confidence dropped.

• Two separate access planes: a key-authenticated API for machine consumers, and a session-authenticated BFF for the operator dashboard.
• Assessment runs on a durable queue, so a slow source never blocks a request.
• Data quality is part of the response rather than a hidden detail — the consumer knows how far to trust the number.
• The model spec, data sources, policy rules and API access are all documented in Persian so banking stakeholders can actually review them.

Stack: Go 1.26، PostgreSQL، Vue 3، Durable queues، Scoring engine

https://eco-trust.ir/

Core banking system — research

A completed research reference implementation targeting 300,000 TPS, on the real 28-digit chart of accounts.

A research effort taken to completion: a reference implementation of a domestic core banking system, built on real data — the 28-digit chart of accounts and the bank’s branch and organisational structure — and on international banking standards. Services in Go with DDD and no ORM; a right-to-left Vue 3 and ECharts dashboard. Twenty-nine technical documents, from the reference architecture through end-of-day, audit and disaster recovery. The research is complete and closed; it never went to production, and was never meant to.

• Persian documentation from the executive summary through the transaction engine, end-of-day, security, audit and business continuity.
• Infrastructure: partitioned PostgreSQL, Redis, Kafka and Kubernetes manifests.
• An explicit performance target with a separate load-test suite — no number is claimed unless it is measured.

Stack: Go، sqlc، goose، PostgreSQL، Redis، Kafka، Kubernetes، Vue 3، ECharts

Yaadestan — Persian self-study platform

Ten self-study courses on one platform: from HTML through deep learning and LLM engineering.

A complete product of my own, published at yaadestan.com — a Persian-language self-study platform, not a single course. Ten courses sit on it, all sharing one authoring standard, one prerequisite chain and one visual language: Taropood (HTML and CSS), Risheh (the maths AI is built on, from zero), Sarnakh (Python → data → ML), Zharfa (deep learning and LLM engineering), Darbast (engineering the code around a model), Marz (research: read, reproduce, publish), Avand (data: SQL, modelling, analysis), Bonyad (algorithms and complexity, measured), Hamhoosh (AI literacy, no code) and AIRO (robotics).

• Most courses are book-first — a self-study book, not a talking-head video. Seven run inside Google Colab, so nobody stalls on environment setup.
• A “Concept Ledger” guarantees no session leans on a concept not yet taught — a curriculum invariant, not a good intention.
• AIRO, the robotics course: five terms, about 56 sessions, complete and accepted. Text-based coding from session one on a real ESP32 — unlike the leading international programmes, which either start with block coding or defer hardware until Python is mastered.
• An in-browser laboratory running MicroPython on WebAssembly with the Wokwi component simulator — a student can start without owning a board.
• One authoring standard across every course: a chapter template, a Persian-RTL-with-LTR-code style guide and an author pack — so adding an eleventh course does not dilute the quality.
• Designed from a review of leading international programmes, effectiveness meta-analyses and the literature on teenage programming misconceptions.
• Nuxt site, Vue laboratory, Go backend and bot — a real product with real users, not a portfolio piece.

Stack: Nuxt، Vue 3، Go 1.26، MicroPython، WebAssembly، Wokwi، ESP32، Google Colab، Motion graphics

https://yaadestan.com

Arena — multiplayer gaming platform

Eleven Go microservices behind a double-entry ledger that reconciles to zero.

A production-grade, event-driven gaming platform: Go microservices on hand-written SQL (no ORM), PostgreSQL, Redis, NATS, a real-time WebSocket gateway and a Flutter client. Every service is hexagonal/DDD with dependencies pointing inward only. The full money path is verified on the machine: register → deposit → idempotent replay with no double-credit → cross-service tournament fee → ledger reconciles to zero → realtime event over the socket.

• Append-only double-entry ledger with a database constraint trigger that rejects any unbalanced journal entry at commit.
• Idempotency keys enforced in SQL, not in application code — a replayed request never double-credits.
• Row-locking plus a database CHECK on balance: overdraw is structurally impossible, not merely guarded.
• The WebSocket gateway carries no business logic — services publish to NATS, the gateway sequences, fans out and replays missed events on reconnect.
• Admin portal in React with TanStack Query/Table; player client in Flutter.

Stack: Go، PostgreSQL، pgx، Redis، NATS، WebSocket، Flutter، React، Docker Compose

Helios — multi-game ecosystem

Platform architecture for 50+ concurrent games, with zero overlapping ownership across 15 domains.

Not a game but an ecosystem: unlimited games, dynamic onboarding, and per-game deploy/upgrade/rollback with zero platform downtime — from one codebase across mobile and desktop. A canonical governance brief locks the decisions and partitions ownership so that no two teams own the same thing. This project is an exercise in product ownership at least as much as in code.

• Explicit, verifiable scale targets: 10M registered users, 1M MAU, 100k CCU, multi-region.
• A 15-domain ownership matrix under a “no overlapping ownership” rule — the governance brief is the single source of truth and older docs get rewritten to match.
• WASM plugin runtime on wazero; game orchestration on Agones and Open Match.
• Locked low-level canon: PostgreSQL with pgx/sqlc/goose, Redis Cluster, NATS JetStream, UUIDv7, integer ledger, transactional outbox, RPO ≤30s and RTO ≤60s.

Stack: Go، PostgreSQL، Redis Cluster، NATS JetStream، WASM / wazero، Agones، Open Match، Flutter، OpenTelemetry

telegram-control — plugin platform

A small core that is the only place a permission is enforced; every feature is untrusted code.

A self-hosted Telegram bot platform whose features are plugins, plus a marketplace for those plugins. Two deliberately separate products: Control is what a customer runs — their bot, their database, their keys; Market is one deployment serving every installation. Control keeps working when Market is unreachable; that is a constraint, not a nicety.

• Sandboxed plugins run in a process with `network: none`, and the supervisor itself executes no plugin code.
• Promotion to the trusted tier needs three independent things: a publisher signature, an entry in Market’s signed index covering that exact tree hash, and the operator naming the plugin. Any one missing and it stays sandboxed.
• Bootstrap via a single-use setup token that is refused outright once anybody can administer the installation — a bootstrap, not a second door.
• Go core, Node plugin hosts, Vue admin panel, Telegram Stars payments.

Stack: Go، Node.js، TypeScript، Vue 3، Docker، Ed25519 signing، Telegram Bot API

Viral Radar

One question, no input required: what is exploding on the internet right now?

A local-first program that answers one question without you typing a topic: what is exploding on the internet right now, and what should I make today? It collects signal from multiple sources, measures growth and recommends. Zero runtime dependencies, entirely local.

• Zero runtime dependencies — the whole collect-and-analyse pipeline runs on the Node 24 standard library.
• Vue 3 web interface with Vuetify and vue-i18n; bilingual docs and UI.
• GitHub Actions CI, MIT licence, packaged to a standalone executable.

Stack: TypeScript، Node.js 24، Vue 3، Vuetify، vue-i18n، esbuild، GitHub Actions

https://github.com/TheServat/ViralRadar

Rivayat — idea to animated series

Cost scales with the number of unique assets, not with frames, seconds or episodes.

A pipeline that starts from a text idea and ends at a multi-episode animated series. Three decisions shape the whole architecture: style is locked first (a StyleBible whose checksum is part of every asset key, so changing style forks the library instead of silently desynchronising it); animation is computed procedurally on a rig rather than generated frame by frame; and one composition renders to YouTube, Shorts, Reels and TikTok.

• A 12-package pnpm + turbo monorepo; architectural boundaries enforced by dependency-cruiser rather than by convention.
• A determinism scan is part of the verification pipeline: output must be reproducible.
• Status stated honestly in the project’s own README: “the engines are done, the studio is half-built.”

Stack: TypeScript، pnpm، Turborepo، Vue 3، Pinia، Vitest، Playwright، Zod

https://github.com/TheServat/Rivayat

Atlas — three-phase coding CLI

The planning phase is not allowed to write code. That single rule shapes the whole tool.

An AI coding CLI in three separated phases: the planning phase analyses the project and produces an atomic, prioritised task plan but never writes code; the coding phase implements each task with tests and verification gates; the polish phase produces a detailed review prompt with no API call at all. Keeping the three apart is what stops plausible-but-wrong code.

• Indexing via go/ast: symbols, dependency and call graphs into SQLite, with FTS5 lexical search plus semantic embeddings behind a hybrid retriever.
• No CGO — pure-Go SQLite and the stdlib parser, so the build just works on every platform and releases cross-compile.
• Per task: checkpoint → code → apply → verify (gofmt, build, test) → reviewer gate → commit, or roll back and retry with the feedback.
• Incremental indexing by content hash, degrading gracefully to lexical-only when embeddings are unavailable.

Stack: Go 1.25، SQLite (modernc)، sqlc، goose، Ollama، Bubble Tea TUI، go/ast

Social CMS — multi-platform publishing

Platform tokens never leave the user’s device.

An installable system for managing social-media content: content production, automated multi-platform and multi-language publishing, trend analysis and tagging. Two principles shape the architecture: platform tokens stay in the device Keychain and the server only knows what should be published when; and client plugins are data, not code.

• The cost of that principle is stated openly: scheduling on iOS cannot be guaranteed, and the UI declares its confidence level honestly.
• PostgreSQL with no ORM — postgres.js with raw SQL and row-level security in the database.
• Every architectural decision recorded as an ADR, each with an explicit “what we gave up” section.
• 22 security tests over the permission and token boundaries.

Stack: TypeScript، Fastify، PostgreSQL، postgres.js، Redis، Flutter، pnpm workspaces

Hybrid Operation Neural Network

About 15× better than int8 on energy and 5× on memory, at equal or better accuracy.

A paper idea taken through to a validated architecture. The original design summed three incompatible numeric representations inside one node — mathematically incoherent. The fix: homogeneous units with a per-channel learnable choice between ternary and power-of-two (APoT) in a shared number space, explicit requantise boundaries, and the logic path split off into a separate single-bit track.

• Method: critique the idea → fix its fatal flaw → implement → validate → optimise → measure on real kernels. Every stage carried a kill condition.
• Every number is measured or estimated from measured op-counts, multi-seed wherever it matters.
• The report is honest: the accuracy win is task-dependent and tunable — no claim of an unconditional victory.

Stack: Python، PyTorch، Quantisation، Custom kernels

PARV-1 — Persian emotional TTS at the edge

Emotional Persian speech, real-time, CPU-only, under two gigabytes of memory.

A research and engineering effort to build a Persian, emotional, voice-cloning TTS that runs in real time on Raspberry Pi and ARM hardware — CPU only, under 1–2 GB of RAM — on BitNet ternary principles. The architecture the research report recommends: a ternary recurrent codec language model.

• Work was sequenced by return on investment: the Persian front-end was built first because it is the dominant source of pronunciation error and costs essentially no compute.
• The front-end is pure Python with zero dependencies, so it runs on the smallest target device.
• A full text-to-phoneme pipeline: Unicode and ZWNJ normalisation, inline emotion tags, number/date/currency expansion, and three-tier G2P with an explicit confidence level.
• The output carries prosodic pauses and control tokens, not just a phoneme string — emotion is part of the representation.

Stack: Python، BitNet / ternary، G2P، Signal processing، ARM / edge

Three market-microstructure studies

The finding nobody wants: direction is not predictable at any tradable horizon.

Three independent studies — is there a market language? is there a tradable equity edge? and the same question on clean crypto data. Every number is checked against saved results by each project’s own verification script (35/35, 29/29, 51/51). Central finding: volatility is the only predictable object, and its path carries more than its level — structure that no GARCH-family process reproduces.

• Designed with kill conditions and kept its negative results — “a better volatility forecast is worth nothing to a trader” was confirmed four independent times.
• The only “signal” in daily equities turned out to be corrupted FX data (a fake 0.80 AUC) — the pipeline finds its own traps.
• One genuine, small finding: a 5-minute reversal, out of sample at z ≈ 6–9.

Stack: Python، Statistics، GARCH family، Information theory، Reproducible research

Ecotam — AI-native headless CMS

The architecture is frozen; changing it takes an RFC with reason, impact analysis, migration path and compatibility assessment.

An enterprise-grade, multi-tenant, AI-native headless CMS platform — built to be operated as commercial SaaS and to be self-hosted from a single binary. Phase 0 completed with the architecture baselined and frozen as BASELINE-1.0: no production code was written, deliberately. This is the clearest example of the work a technical product owner actually does — locking decisions before spending.

• Formal change control: implementation documents are not permitted to redesign the architecture, and any deviation must go through an RFC.
• More than thirty ADRs, each with explicit scope, reasoning and consequence.
• Even the product name is a recorded decision — because naming and product scope are the owner’s job, not an afterthought.

Stack: Go، PostgreSQL، sqlc، Multi-tenant، ADR / RFC process

Voice Changer — character voice workshop

Fifty dialogue lines went from 57 minutes to 8, purely by keeping the model in a persistent worker.

Turns your own recorded Persian dialogue into character voices — voice conversion, not text-to-speech. You act; only the timbre changes, while your intonation, rhythm, pauses and emotion survive. Raw engine output sounds telephonic; three layers of restoration and mastering take bandwidth from 10.8 kHz back up to 18.5 kHz.

• Two engines benchmarked and the choice documented: Seed-VC handles Persian pronunciation about twice as well as Chatterbox.
• Quality chain measured at every stage, ending at 44.1 kHz and −16.0 LUFS.
• Entirely local on a 6 GB Quadro RTX 3000 — designed under a real hardware constraint.

Stack: Python، FastAPI، Seed-VC، CUDA، Audio DSP

Persian emotional speech dataset

100% local — no cloud or LLM API is ever called.

Builds large, richly annotated Persian speech datasets for TTS, voice cloning and speech understanding — entirely on your own machine. Two independent pipelines: TEXT (crawl Persian text → spoken-style utterances with emotion and prosody labels) and AUDIO (real human Persian speech, sentence-split, with transcripts and audio-derived labels).

• Crawling, separation, transcription and labelling all run locally on CPU or GPU.
• Resume, dedup and a run lock designed in from the start — built for multi-day runs.
• Full right-to-left Persian documentation alongside the English docs.

Stack: Python، Whisper، Audio separation، Web crawling

Hokm — real-time multiplayer

One game, three transports: internet, LAN and Bluetooth.

The Persian trick-taking card game, real-time and multiplayer, with server-authoritative game logic. Flutter client, Go backend, PostgreSQL and Redis. Beyond online play it supports LAN play over mDNS and TCP, and Bluetooth play — plus AI opponents at three difficulty levels, spectator mode and a reconnect system.

• Game logic is server-authoritative: the client is never the source of truth.
• A full technical specification with subsystem breakdown, test plan and architecture document was written before the code.
• Scale target: 1M concurrent users and 10k active game rooms.

Stack: Go، Flutter، PostgreSQL، Redis، WebSocket، mDNS، Bluetooth

Intl-carbon — Jalali calendar for PHP

Published in 2015, still collecting stars on GitHub.

A Carbon extension for PHP with IntlCalendar support — Jalali dates handled as fluently as Gregorian ones. My oldest public code that still works and still has users, which is its own kind of test: code that is still usable a decade later.

• My oldest public code, 2015 — and evidence that I was shipping open source long before the agentic era.
• A real Iranian-developer problem: Jalali dates inside a Gregorian ecosystem.

Stack: PHP، Carbon، IntlCalendar

https://github.com/TheServat/Intl-carbon

Backend & services

NestJS، Node.js، TypeScript، Go، PHP / Laravel، Express.js، Fastify، Koa.js

Architecture & integration

Microservices، REST API، GraphQL، gRPC، RabbitMQ، Kafka، NATS JetStream، Swagger / OpenAPI، WebSocket، Event-driven design، DDD / Hexagonal

Data & storage

PostgreSQL، MySQL، MongoDB، Redis، Double-entry ledgers

Frontend & client

Vue 3، JavaScript ES6+، CSS3، Vite، React، Flutter

Platform & operations

Docker / Compose، Linux، Crawlers & scraping، CI (GitHub Actions)، Observability (OTel)، Networking & infra