# **Contents
`table_of_contents`

# Overview
**Artem Gevorkyan** — Python backend engineer — Django, Celery, FastAPI, Redis, PostgreSQL. I build products and run them in production.

I designed, built and operate articha.ru — a Django service with 11 apps, payments, an OpenAPI surface, a published PyPI client and a Chrome extension — self-hosted on a Raspberry Pi, 733 commits and counting.

Open to offers. Moscow region, Russia.

Languages:
- Russian — native
- English — conversational, fluent technical reading and writing

How to get in touch:
- email — tima-1324\@mail.ru
- Github — https://github.com/ArtichaTM
- Telegram — https://t.me/ArtichaTM
- Feedback form — https://articha.ru/about/contacts

## How I work

**I ship the whole vertical.** One idea became six artifacts: a document engine, a product that hosts it, a typed public API inside that product, a published command-line client, a browser extension, and the version-controlled infrastructure it all runs on — with deploy alerting wired into my own monitoring. Most of what I build ends up with a complete product surface rather than a repository. 

**Every project started as my own problem — and I checked before building.** I could not format documents to the Russian state standard, so I surveyed what existed, found nothing that fit and several projects too stale to build on, and only then wrote my own. I then wrote an 88-page thesis with it before offering it to anyone else. The generator-exercise tool exists because I was tutoring students on generators. The scraper and the browser extension exist because a course put its pages behind authentication. Nothing here is a tutorial project. 

**I teach the thing I build.** Over 120 verified task check-offs for other students, a paid exam briefing for thirty-five people, and one-to-one tutoring through an entire course — then I automated my own teaching domain with three tools built for it. Explaining send() and throw() to a room and then building a generator that produces graded exercises on the same topic is the same skill pointed in two directions. 

**I can tell when a design has stopped paying for itself.** A Django site rebuilt from scratch when its foundation could not carry the next feature. A game-server plugin rewritten from Python into C++20 when the platform changed. An exercise generator rebuilt around a task registry. A thesis architecture generalised into a standalone one. An engine migration out to Godot and back. Each restart followed a specific change in constraints, and each successor shipped further than the thing it replaced. 

**I document decisions, not just usage.** A design document written before implementation. A test suite with a scenario table enumerating thirteen sync cases and the HTTP verbs each should produce. A README that records every judgement call and every deviation from the brief. Several of them record deferred decisions and open questions explicitly rather than pretending completeness. 

**I know when to stop.** Asked to build a classifier separating two closely related diseases, I ran the exploratory analysis first, concluded the data could not support a reliable model, and said so instead of shipping one. A negative result delivered early is worth more than a classifier nobody should trust. 

**Small independent pieces plus a coordinator.** Traits composing into skills in a game-server plugin. Nineteen assembly definitions with enforced compile-time boundaries in a Unity project. Twenty-five independent macro modules in a document engine. Independent competency networks weighted at runtime in a thesis. An engine split from its client — twice, in unrelated domains. The same instinct across game modding, document rendering and machine learning. If there is one thing to know about how I build, it is this. 

What all of it adds up to is in the table below. Some of the numbers are counted from this site's own database and move with it; the rest are the author's repositories and packages.

`table_name: What the work adds up to`

| Metric | Value |
|---|---|
| Registered accounts | 55 |
| Projects created | 59 |
| Documents rendered | 379 |
| Fast conversions | 97 |
| Files stored | 122 |
| Public and private repositories | 39 |
| Commits across them | 2790 |
| Packages published to PyPI | 1 |
| Languages shipped in | 7 |

![Artem Gevorkyan](./photo.png)

# Projects
Projects are grouped by weight rather than by date: first the ones described in full that are still running, then the finished and substantial ones, then a short list of everything else. Every one of them began as a problem the author had.

## Flagship
### articha.ru
Designed and operate articha.ru, an eleven-app Django 6 service with Celery workers, a mounted FastAPI public API, card payments and full Russian localisation — self-hosted on a Raspberry Pi behind nginx, systemd and Cloudflare.

2025-02 → present. Live. Private repository. Role: solo, 712 of 733 commits. Scale: 411 files, 11 Django apps.

Stack: Python 3.12, Django 6, django-allauth, FastAPI, Celery, Redis, PostgreSQL, psycopg3, uWSGI, Bootstrap 5, htmx, CodeMirror, Plotly, Cloudflare API, nginx, systemd, i18n.

What matters in it:

- Hybrid Django + FastAPI in a single deployment, with a published client against the API
- A custom app that inlines and caches CSS — a performance layer written rather than installed
- Full Russian localisation with per-app catalogs
- Deploy alerting into self-hosted monitoring, with severity-differentiated escalation
- A management command driving the Cloudflare API, chosen over dynamic DNS after measuring both
- Small deliberate touches: a trust gauge widget, an easter-egg game page

Links:
- articha.ru — https://articha.ru

### Markdown Gost
Built a Markdown → DOCX engine generating standards-compliant documents: a 25-macro extension system, two-pass cross-referencing, LaTeX → OOXML formula conversion, and automatic numbering of every numbered entity in the document — running in production behind articha.ru.

2025-01 → present. Live. Private repository. Role: solo, 136 of 139 commits. Scale: 85 files.

Stack: Python 3.12+, python-docx, marko, lxml, sympy, latex2mathml, XSLT, Graphviz, Pillow, hatchling.

What matters in it:

- Two-pass rendering, so forward references resolve
- Automatic numbering of every numbered entity: headings, figures, formulas, tables, appendices
- LaTeX → MathML → OOXML formula conversion through XSLT
- An optional cache for remote sources
- Fifteen or more real documents rendered, including work written on someone else's behalf and a law-faculty article

Links:
- articha.ru — https://articha.ru/mgost

### MGost
Published an async Typer CLI that syncs local markdown projects with a cloud renderer — including a three-pass file-identity matcher that refuses to guess when running unattended, backed by a documented 13-case scenario suite with mocked HTTP and Windows CI.

2025-10 → present. Live. Public repository. Role: solo, 119 commits.

Stack: Python 3.13, typer, httpx, Pydantic, aiofiles, aiopath, rich, pytest + asyncio/xdist/respx, hatchling, MIT.

What matters in it:

- Three-pass file-identity matching that refuses to guess when unattended
- A documented thirteen-case scenario suite with mocked HTTP and no network
- Cross-platform CI including Windows
- Lint, tests, coverage and PyPI publishing from CI

Links:
- MGost on GitHub — https://github.com/ArtichaTM/MGost
- mgost on PyPI — https://pypi.org/project/mgost

### Modular AI for Rocket League
Bachelor's thesis, graded 5/5: a modular reinforcement-learning architecture — independent competency networks weighted at runtime by a learned selector — implemented as a PyTorch client driving a C++ plugin over a schema-defined binary socket protocol.

2025-01 → 2025-05. Complete. Public repository. Role: solo, 221 and 19 commits across two repositories.

Stack: Python, PyTorch, Cap'n Proto, PySimpleGUI, C++, MSVC, ImGui, DirectX 11, BakkesMod SDK.

What matters in it:

- 88 pages plus six appendices, another 48 pages
- A cross-language, cross-process real-time control loop over a schema-defined binary protocol
- A composable reward library with a documented extension template
- Dual CUDA and CPU torch indexes declared per platform

Links:
- MAI-Client on GitHub — https://github.com/ArtichaTM/MAI-Client
- MAI-Server on GitHub — https://github.com/ArtichaTM/MAI-Server

## Substantial
### WCSSkills
Designed and implemented a Counter-Strike server plugin twice — first in Python, then rewritten in C++20 — featuring a trait-based status-effect engine, a JSON-driven data layer, custom container and scheduler implementations, and a GoogleTest suite on Linux and Windows CI.

2021-10 → 2023-01, then 2023-11 → 2024-01. Archived. Public repository. Scale: two full implementations.

Stack: Python, Source.Python, C++20, CMake, GoogleTest, SQLite C API, metamod, nlohmann/json.

What matters in it:

- A trait interaction system where combinations disable each other by rule
- A hand-written doubly linked list, generic data storage and tick scheduler
- A GoogleTest suite with a leak checker, on a CMake CI matrix across Linux and Windows

Links:
- WCSSkills on GitHub — https://github.com/ArtichaTM/WCSSkills
- CS2_WCSSkills on GitHub — https://github.com/ArtichaTM/CS2_WCSSkills

### DRF and Angular fullstack
Built a containerised fullstack application — a Django REST Framework API with WebSocket chat via Channels and Daphne, and an Angular SPA with server-side rendering — deployed behind nginx with Docker Compose.

built 2025-05, published 2026-08. Complete. Public repository. Role: solo, 56 commits across two repositories.

Stack: Django 6, Django REST Framework, Django Channels, Daphne, django-filter, django-cors-headers, Angular, TypeScript, SSR, Docker Compose, nginx.

What matters in it:

- Custom authentication and serializers over DRF
- WebSocket chat through Channels and Daphne
- Angular standalone components with server-side rendering
- Docker Compose with a development override, nginx, and deploy scripts for both Windows and Linux

Links:
- dataanalyst2-backend on GitHub — https://github.com/ArtichaTM/dataanalyst2-backend
- dataanalyst2-frontend on GitHub — https://github.com/ArtichaTM/dataanalyst2-frontend

### File downloader and digit analyzer
Built a Django 6 / ASGI + htmx service backed by Celery, Redis and PostgreSQL that drains a rate-limited external catalog under a distributed pacer and lock, with a fully network-free test suite.

2026-07-27, one day. Submitted. Public repository.

Stack: Django 6 on ASGI, htmx, Celery, Redis, PostgreSQL, nginx, Docker Compose, uvicorn, whitenoise, Flower, respx, i18n.

What matters in it:

- A README with a configuration table, explicit constraints and a frank security note about what is and is not a secret
- Redis-backed request pacing and download locks
- A fully network-free test suite

Links:
- Test_InstallBiz on GitHub — https://github.com/ArtichaTM/Test_InstallBiz

### Full-text document search service
Built an async full-text search service on FastAPI, Elasticsearch and PostgreSQL with a two-stage retrieve-then-rank pipeline and an idempotent CSV importer.

2026-07. Submitted. Private repository.

Stack: FastAPI, Elasticsearch, PostgreSQL, SQLAlchemy 2.0, asyncpg, Typer, Docker Compose, pytest-asyncio.

What matters in it:

- Async throughout: FastAPI, the Elasticsearch client, and asyncpg
- Idempotent CSV import
- A Typer CLI alongside the HTTP API

### Nova3D
Built a 3D roguelike in Unity across 500+ commits, structured into 19 assembly definitions with JSON-driven content, reactive state via R3, full localisation and Doxygen documentation published from CI.

2024-02 → 2025-05. Stale. Private repository. Scale: 511 commits, 499 files.

Stack: Unity, C#, URP, VFX Graph, Unity Localization, Addressables, Newtonsoft.Json, R3.

What matters in it:

- Nineteen assembly definitions with compile-time enforced boundaries
- JSON-driven game content
- Reactive state through R3
- Full Russian and English localisation
- Doxygen documentation published from CI

### Production infrastructure
Version-controlled the full production stack for a live service — nginx with rate limiting, Redis, and three systemd units for site, API and worker with sdnotify readiness — on self-hosted hardware.

2026-07 → present. Live. Private repository. Scale: 15 files.

Stack: nginx, systemd, Redis, Raspberry Pi.

What matters in it:

- nginx, Redis and three systemd units under version control, with installers
- sdnotify readiness rather than a guess at startup time
- Rate limiting and per-site logging configured at the proxy
- Fifteen files that describe the production machine completely

## Smaller work
Work that fits on one line: coursework and paid tasks, bots, utilities and one-off jobs. None of them has a page of its own, and they show breadth rather than depth, which is why they are collected into a table.

`table_name: Smaller work`

| Project | Period | Status | What it shows |
|---|---|---|---|
| ATON — currency rates site | 2024-05 | Submitted | 171,418 rows loaded with bulk_create; a background updater thread beside Django; one-second anti-spam pacing, with the full refresh measured at 3 h 39 m and documented; interactive Plotly graphs; an honest bug list in the README |
| ATON — C# Web API | 2024-05 | Submitted | ASP.NET Core with EF Core and Swagger |
| ATON — T-SQL tasks | 2024-05 | Submitted | Transaction isolation levels; grouping by date parts; LAG/LEAD window functions wrapped in a subquery because WHERE cannot touch them; plus an algorithm task solved with a documented six-step method and a complexity estimate |
| workmate_test — CSV report CLI | 2026-03 | Submitted | Zero runtime dependencies; prefix-based aggregation; packaged as an installable distribution; pre-commit, flake8, pytest and Coveralls; graceful per-column error reporting |
| OfferDjango — Bootstrap 5 from Figma | 2026-02 | Submitted | Django and Bootstrap 5 built from a Figma file; file uploads, drag-and-drop ordering, synced galleries with fullscreen, a Russian-language admin; a README documenting every judgement call |
| data-analyst-1 | 2026-04 | Submitted | pandas and openpyxl producing an Excel report with conditional formatting; documented assumptions; a conclusion verified against the data rather than assumed |
| KisPyGenerators2 | 2023-12 | Complete | A metaclass-driven task registry; composable exercises with serialisation; complexity-ranged random generation; a validator driving a candidate generator through send() and throw() and returning a diagnostic; CI across Python 3.7–3.12 |
| KISHelper | 2024 | Source gone | An aiogram bot with solvers for four task types, each split into parser and solver; SVG parsing; HTML caching; a settings watcher; MkDocs documentation; per-task fixtures with saved pages |
| KISSolver | 2025-04 | Source gone | An image → OCR → LaTeX → executable Python pipeline: statements published as rendered images recovered with OCR, parsed as LaTeX, translated into Python and evaluated. Stopped working when the upstream source closed access |
| ArtichaChromeExtension | 2025-03 | Live | A Chrome MV3 extension uploading authenticated pages so their content stays readable without re-authenticating; crx packaging; a self-hosted update feed served by the Django app |
| AA_Voices | 2024–2025 | Stale | An async scraper pulling a voice-line dataset from a public game-data API, with audio tagging, plus voice-synthesis training scaffolding. 135 commits |
| translator | 2023-11 | Complete | Three libraries in one, built during a three-day competition: pivot translation through an intermediate language; an FFmpeg wrapper using stream copy, measured at 431 invocations over 4.11 GB in 28.3 seconds; and a subtitle writer implemented as a generator you send lines into |
| MNIST8 | 2024-11 → 2025-03 | Complete | A Vitis HLS C++ implementation of a 12,730-parameter network for small neural processors, with a hand-written matrix-multiply kernel, verified in C simulation against the reference model |
| medical_ai | 2024-02 | Complete | Asked to build a classifier separating closely related diseases, ran the exploratory analysis first, concluded the data could not support a reliable model, and stopped |
| DiscordBot | 2024 | Source gone | Per-user online and in-game time tracking; a SQL schema per feature module; matplotlib charts. 99 commits. Stopped when the platform was blocked in Russia |
| ReminderBot | 2023-05 | Complete | A Telegram reminder bot optimised for very fast entry — its one differentiator over a general calendar. A university pair project, and the only collaborative repository here |
| SomeMagazineBot | 2023-10 | Stale | A deliberate skill-stretch to learn SQLAlchemy and PyMySQL. Verdict recorded: I prefer the Django ORM |
| OrangePiDjango | 2023 | Archived | The predecessor to articha.ru, abandoned because its foundation could not carry what came next — which is why the successor was started clean |
| VK_community_bot | 2022 | Stale | A bot controlling my own machine remotely. 36 commits |

# Skills
Not one line below carries a self-rating out of ten. Each names the work that proves it instead — and all of that work is described under Projects.

## Daily, deep
The stack I reach for without thinking, and the work that proves each line.

**Python 3.10 → 3.13** — Modern typing, the generator protocol from the inside (send/throw), metaclasses, __slots__, dataclasses, ABCs, context managers, generators used as coroutines.

**Django 5.x / 6.x** — A ten-app production project: ORM, custom model fields, migrations, admin customisation, custom auth backends, signals, management commands, template tags, i18n, ASGI and WSGI, the static pipeline, custom 403/404/500 pages.

**Django REST Framework** — Serializers, custom authentication, django-filter, CORS.

**Django Channels + Daphne** — WebSocket consumers and routing for a realtime chat.

**async Python** — asyncio, aiohttp, httpx, aiofiles, aiopath, async SQLAlchemy and asyncpg, pytest-asyncio.

**Celery + Redis** — Real task queues with workers under systemd, Flower, and a broker-agnostic design.

**FastAPI** — Mounted as a sub-application inside a Django project to serve the public API — Pydantic schemas, routers, an OpenAPI description consumed by a published client.

**htmx** — In production: partial swaps, progress polling, batched "show more", selection state preserved across pages.

**Bootstrap 5** — A production site, and a build straight from a Figma file.

**Angular + TypeScript** — Standalone components, services, routing, server-side rendering.

**PostgreSQL** — psycopg3 with the binary driver and a connection pool; asyncpg on the async side.

## Repeatedly demonstrated
Not daily work, but shipped more than once and to completion.

**C++17/20** — CMake, GoogleTest, hand-written containers, a tick scheduler, the SQLite C API, a plugin ABI, Cap'n Proto, ImGui on DirectX 11.

**C#** — .NET 8 with ASP.NET Core Web API, EF Core and Swagger; Unity across nineteen assembly definitions with URP, VFX Graph, Localization and Addressables; Godot 4.6; R3 reactive extensions.

**SQL** — T-SQL with window functions, isolation levels, transactions and indexes; SQLite schema design and its raw C API; PostgreSQL; MySQL.

**ML / PyTorch** — Reward-function libraries for reinforcement learning, modular network composition, training loops, replay memory, live loss plotting; Keras and TensorFlow for a classifier.

**Testing** — pytest with asyncio, xdist and respx; unittest; coverage and Coveralls; GoogleTest; deliberately network-free suites; Windows CI; documented scenario tables.

**Operations and self-hosting** — nginx site configs with rate limiting and logging, systemd units with sdnotify readiness, Redis configuration, Docker and Compose, Cloudflare API automation, deploy alerting, uptime monitoring, running it all on a Raspberry Pi.

**Tooling discipline** — uv, hatchling, ruff, flake8, isort with a custom section order, pre-commit, ty with django-stubs and celery-types, semantic versioning, and a git hook that refuses direct commits to the main branch.

## Working knowledge
Used for real work, on a smaller surface.

**Elasticsearch** — Async client, index design, and candidate re-ranking in the database.

**Data analysis** — pandas, openpyxl with conditional formatting, matplotlib, Plotly, Colab.

**Bots** — aiogram, discord.py, the VK API.

**Browser extensions** — Chrome MV3, crx packaging, a self-hosted update feed.

**Web scraping** — BeautifulSoup4, lxml, SVG parsing, HTML caching.

**OCR and symbolic translation** — pix2tex, pytesseract, pylatexenc — an image → OCR → LaTeX → executable Python pipeline.

**Document generation** — python-docx, direct OOXML manipulation, MathML → OMML through XSLT, LaTeX → MathML, Graphviz.

**FPGA / HLS** — Vitis HLS C++ for small neural processors.

**Media** — An FFmpeg wrapper doing stream-copy mux and demux, argostranslate, SRT generation.

**SQLAlchemy 2.0** — Used, and not preferred — the Django ORM does the same work with less ceremony.

# Experience
## Work
**Python tutor and task consultant**, kispython, a university Python course (2023 → present)

Sustained paid technical teaching, alongside the tooling I built for the domain because I was in it.

- Over 120 verified task check-offs delivered for other students; more than 200 counting directly paid work outside the official tally
- Ran a paid group exam briefing for 30–35 students on what the course exam would cover, with turnout beyond what was expected
- One-to-one tutoring through every task on the course — a single engagement paying roughly what completing tasks for five people did
- Built three tools for the domain along the way: an exercise generator, a task automation bot, and the solver engine behind it

**Independent developer — self-employed**, articha.ru (2025 → present)

Registered self-employed, running a live monetized service with a public offer, a personal-data policy and card payments.

- Designed, built and operate articha.ru end to end — application, deployment, monitoring and payments
- Revenue is small but real; the site also generates leads for work paid directly rather than through the platform
- The full production stack is version-controlled and self-hosted: nginx, Redis, three systemd units, and a Cloudflare-fronted dynamic address

## Education
**Bachelor's degree** — RTU MIREA, Moscow (2021 – 2025)

09.03.04 Software Engineering, full-time. Specialised in intelligent decision-support systems. Thesis «Модульная нейронная сеть с плавающим влиянием на вывод» — A Modular Neural Network with Floating Influence on Output — defended with the top grade, 5/5. Diploma issued 8 July 2025.

**Master's degree** — MIREA (2025 → present)

## Certificates
**Samsung Innovation Campus — Artificial Intelligence track** — Samsung Innovation Campus / IT Academy, Moscow, June 2025

136 academic hours, completed with a graduation project defended. Certificate №2077393301.

**Digital Breakthrough. Season: Artificial Intelligence** — ANO "Russia — Land of Opportunity", November 2023, 3rd place, district stage, North-Caucasian Federal District

Case: automatic dubbing of video into another language. My contribution was the translation and media pipeline, built inside the three-day competition window.

**IT Academy Hack 2024** — Samsung Innovation Campus, April 2024

All-Russian hackathon on scientific volunteering and ecology. Participation.

Currently researching a new approach to developing neural networks.

# Timeline
The same material, in order of time: from the first program to the most recent of everything above. The rows set in bold are the ones that changed the direction of the work rather than continuing it.

`table_name: Timeline of the work`

| Period | Event | Detail |
|---|---|---|
| ~2016 | Starts programming in Python | At school. A calculator, as everyone's first program is |
| 2018-12 | GitHub account created |  |
| ~2019 | First Django | Already building web applications, alongside utility scripts and automation |
| 2021 | Enters RTU MIREA | 09.03.04 Software Engineering |
| 2021-09 | First Django repository | One commit, in the first month at university. A marker, not a project |
| 2021-10 → 2023-01 | WCSSkills | First large project, 103 commits |
| 2022 | VK_community_bot |  |
| 2023-04 → 2023-05 | ReminderBot, and the first exercise generator |  |
| 2023-09 → 2023-10 | OrangePiDjango · SomeMagazineBot |  |
| 2023-11 | **3rd place, Digital Breakthrough: AI** | The translation and media pipeline built during it. The C++ rewrite of WCSSkills begins the same month |
| 2023-12 → 2024-01 | KisPyGenerators2 |  |
| 2024-02 | medical_ai | First research task — and the first one I concluded should not ship |
| 2024-02 → 2025-05 | Nova3D |  |
| 2024-04 | IT Academy Hack 2024 | Participant |
| 2024-05 | ATON test assignments | Python, C# and MSSQL tracks |
| 2024-07 → 2024-10 | DiscordBot · KISHelper |  |
| 2024-11 → 2025-03 | MNIST8 |  |
| 2025-01 → 2025-05 | **Bachelor's thesis, defended 5/5** |  |
| 2025-01 → now | **Markdown Gost** | The document engine |
| 2025-02 → now | **articha.ru goes into production** |  |
| 2025-04 | KISSolver |  |
| 2025-05 | dataanalyst2 |  |
| 2025-06 | **Samsung Innovation Campus certificate** | 136 hours, graduation project defended |
| 2025-07-08 | **Bachelor's degree awarded** | 09.03.04 Software Engineering, RTU MIREA |
| 2025-09 → now | Master's degree, MIREA |  |
| 2025-10 → now | MGost client published to PyPI |  |
| 2026-02 → 2026-04 | Test-assignment round | OfferDjango, workmate_test, data-analyst-1 |
| 2026-06 → now | Research | Currently researching a new approach to developing neural networks. |
| 2026-07 | Infrastructure in version control, and two more test assignments |  |
| 2026-08 | dataanalyst2 published |  |

# **About this document
Nobody typed this document. It is built from the same records the resume pages at https://articha.ru are built from: every project, skill, experience entry and number above was placed here by a loop over those records, and a fact corrected there cannot survive here.

The markup was turned into .docx by Markdown Gost — a document engine for the Russian state standard, written by the author of this resume and running on that same site. The layout is the one the standard prescribes, which is also why the figure caption below the photo is in Russian in both languages.

The source of this document is offered beside it: download cv.md and photo.png, put them in one folder and hand them to the fast converter at https://articha.ru, and you get exactly what you are reading.

The date and time below were written by the engine at conversion time, not by the template when the markup was built: if you rendered this file yourself, what stands here is your build, not ours.

Built: `today: %d.%m.%Y %H:%M`