Daniil Vdovin

Open to offers

RUEN

I take a project from Your pain point to a green release and the final tweak.

One person for the whole cycle: pain point, spec, code, team, demo, handover.

Message on TelegramDownload CV

or by emaildaniilvdovin4@gmail.comdvkbusinessru@yandex.ru

Any projectthe cycle
  1. Client01What hurts, the deadline, the budget.
  2. Me02A call: questions that remove the risks.
  3. Me03Spec and a ranged estimate, exclusions listed.
  4. Me04Architecture and tasks cut into clear pieces.
  5. Agent05Writes the code for the task, tests included.
  6. Check06A test failed. Rejected.
  7. Agent07Fixed it, checks are green. Accepted.
  8. Me08Review of code and decisions against the spec.
  9. Me09Release, monitoring, rollback plan.
  10. Me10Client demo, I run it myself.
  11. Client11Watches the demo, sends changes.
  12. Me12Changes go in, the next round starts.
People and agents pass the same checks.
Daniil Vdovin, pixel portrait

About me

Tech lead and developer in Go and TypeScript. A year and a half of commercial work, and lately I run projects end to end: I talk to clients, write the spec and the estimate, lead the team, ship and show the result.

I write code that others can understand: clear module boundaries, tests, documentation. I read other people's code and ask questions before implementing.

AI is part of my work every day: Claude Code with custom MCP servers, architecture planning, TDD, and agents checked by the same gates as people. I'm growing towards complex backend systems and a lead role: reliability, performance, mentoring.

1 person
Fewer handoffs, less information lost
Demo
I keep showing it until you like the future product
AI on the team
Agents take the routine: faster and cheaper

HR: the short version

Everything you need before the first call.

  • RoleTech lead or lead developer, Go and TypeScript
  • ExperienceCommercial development since November 2024; I run clients, the team and demos
  • FormatRemote or hybrid, Yekaterinburg, UTC+5
  • StartBy agreement
  • EnglishB1–B2, technical, improving
  • EducationUral State Mining University, big data specialist (computer vision)
  • CVCV as PDF

Experience

Where I work and what I did. Duties expand on click.

Multimedia Video Systems

Fullstack Developer

October 2025 - Present

  • Lead contributor on a client product: about 2/3 of commits over three months across a team of eight
  • End-to-end presale flow brief → spec → bill of materials → proposal: document versions and a public link for client approval
  • Normalized equipment catalog with an MCP server on FastMCP: an item is published only with its key specs filled in, and the catalog has a readiness metric
  • Standard solutions and an equipment selection wizard by room and subsystem
  • Proposal export to 1C (CommerceML 2.05)
  • Claude Code (CLI) as the main AI tool: MCP servers (Serena, Context7, Playwright, Figma), AI-driven TDD, custom skills for debugging and code review
Duties by area
Development methodology
Every T-xxx task comes with a spec and tests built on CJM scenarios. Architecture decisions are recorded in ADRs.
Architecture & design
FastAPI backend with api / models / schemas / repositories layers, Alembic migrations. A separate catalog MCP server on FastMCP.
Backend (Python / FastAPI)
SQLAlchemy 2, Pydantic 2, JWT + Argon2id, multiprocess via gunicorn and UvicornWorker. Proposals in three variants: Base, Optimal, Premium.
Frontend (React / TypeScript)
React 19, Vite 7, TanStack Query, Zustand, React Hook Form + Zod, Tailwind 4. Equipment selection wizard and the standard solutions window.
AI tools
The brief becomes a spec through Codex, and a human checks the result. The catalog is filled through Claude Code and the MCP server.
DevOps & infrastructure
CI in GitHub Actions, S3-compatible storage (MinIO), PostgreSQL 16.
Testing
pytest, Vitest + RTL, Playwright e2e on CJM scenarios, mutation testing.
Integrations
Proposal export to 1C (CommerceML 2.05), MinIO for files, public links to specs and proposals for the client.

Anvirtekhno

Fullstack Developer

November 2024 - Present

  • 1+ year of stable remote work in a team: regular delivery, code review approved on first-second attempt
  • Auto-generated TypeScript clients from OpenAPI: eliminated entire class of errors in frontend/backend sync
  • Built PWA with offline mode and push notifications - app works without internet and installs as native
  • Connected LLM providers (OpenAI, Ollama) to production with fallback strategy and token monitoring
  • Built PostgreSQL + MinIO auto-backup system with encryption and offsite sync
  • Claude Code (CLI) as primary AI tool: MCP servers (Serena, Context7, Playwright, Figma), AI-driven TDD, custom skills for debugging and code review
Duties by area
Development Methodologies
API-first approach: OpenAPI spec → auto-generated TypeScript clients. TDD for business logic. RDD for feature planning before implementation. TypeScript types from DB schemas.
Architecture & Design
Clean Architecture on NestJS modules. REST API with auto-documentation from decorators. Event-driven approach for loosely coupled components. Structure ready for microservice extraction.
Backend (NestJS / TypeScript)
NestJS as primary stack. JWT auth with refresh tokens. Background jobs and scheduled tasks. LLM providers (OpenAI, Ollama) with fallback strategy and token monitoring. Telegram Bot integration.
Frontend (React / TypeScript)
Next.js PWA with offline mode and push notifications. Zustand + SWR for state management. React Hook Form + Zod for validation. Component library in Storybook. i18n and theming.
AI Tools
Claude Code (CLI) for code review, debugging and refactoring. MCP servers: Context7 (docs), Playwright MCP (E2E), Figma MCP (design). TypeScript language server for code intelligence. Custom skills.
DevOps & Infrastructure
Docker + Docker Compose, multi-stage builds. Auto-backups PostgreSQL + MinIO with encryption and offsite sync. CI/CD in GitHub Actions, Dependabot. Observability: Prometheus, Grafana, Loki.
Testing
Jest unit tests for TypeScript/Node.js. E2E with Playwright. Mocking for LLM providers and external services. Tests integrated in CI/CD: PRs don't merge without green matrix.
Integrations
LLM providers (OpenAI, Ollama) with fallback and monitoring. Telegram Bot API. S3/MinIO for storage and backups. Composio Gmail API for notifications.

For managers: six stages, one person

Pick a stage: what I do and what you get. The team is people and AI agents, and the checks are the same for both.

I do

I talk to the client myself and find out what hurts.

You get

Questions answered before the estimate

Sample artifact

questions before the estimate

  what hurts today
  what a mistake costs
  the deadline
  who decides

Results: before and after

The same results for a manager, HR and a developer. Pick how to read them.

Read as

Reading a user from the database

hot reads from cache
Before
database query
After
~0.5–1 ms from cache

Repeat reads are served from the cache: the database is offloaded and the client gets an answer faster.

Detecting an incident

monitoring from scratch
Before
no monitoring
After
minutes

An outage shows up in minutes: less downtime.

≈ 7,900 RUB a month · ≈ 95,000 RUB a year4 h of incident hunting a month × 1,970 RUB/h. Rate: Go median, Habr Career, H1 2026; hours are an estimate.

Delivery speed

163 releases in May 2026
Before
4 months
After
189 releases

Changes ship in small pieces: 189 releases in 4 months, so a bug touches less and rolls back faster.

Front-end and back-end mismatches

a whole class of bugs gone
Before
hand-written types
After
clients generated from OpenAPI

Fewer production bugs: the team's hours go to new features.

Share of the client product

lead developer
Before
8 contributors
After
~2/3 of commits mine

About two thirds of the product's commits over three months came from one person: the main pace of development rests on me.

Projects and demos

Under each project: what you see, what I did and the result.

Client product, B2B, unnamed

Lead developer of the product

~2/3
of commits
8
contributors
3 mo
period
What you see
Video: the presale flow and what I worked on
What I did
Modules with tests, docs and CI; Redis cache; sync with 1C and Telegram
Result
Live: about 2/3 of commits across eight contributors

AI for tenders, employer's product

Tender review with AI

78
seen
51
reviewed
22
shortlisted
What you see
How AI works through a tender: from documents to a bid
What I did
Document review, go/no-go scoring, a shortlist for the team
Result
Live: the client’s tender specialists now work more efficiently

Wholesale, client, unnamed

Stock agent on the website

What you see
A buyer asks on the website, the agent answers from stock right away
What I did
Demo before the product: a widget answers from the Excel stock by city and hands large orders to a manager; landing page
Result
Launching: managers stop answering “is it in stock” by hand

Flat renovation, client, unnamed

3D pricing story

3
plans
4
layouts
0
site edits
What you see
Renovation plans as wall layers, the flat rebuilds from the area
What I did
Three.js scene, the flat rebuilds from the area, a video on the live site without touching it
Result
Launching: integration into the client's site

My product

English Hub

What you see
Flight board, city map and live scenes
What I did
AI conversation partner, a 3D city, sync, plans at 390 and 790 RUB
Result
Live: users are already exploring new cities

My product, open source

kb-engine

28
releases
392
commits
246
test files
What you see
Video: scattered articles and notes come together in one base
What I did
A knowledge base engine in Go: CLI, TUI and web over one layer
Result
Live: now I lose and forget nothing

Code on GitHub

My product

Floq

731
commits
v0.118
version
503
test files
What you see
A sales assistant next to your CRM
What I did
AI emails, Email and Telegram sequences, lead qualification; 731 commits, 503 test files
Result
Live: clients who work alone are no longer on their own, they now have an assistant

Product with a partner, open source

zamo

What you see
AI writes, a human approves
What I did
A knowledge base where every AI edit waits for review; co-author, 34 of 154 commits
Result
Launching: final preparations under way

Code on GitHub

Projects in detail

Architecture, backend, infrastructure and tests of each project. Click to expand.

Deal Sense - AI for Tender Teamsv0.334.0, 5 AI providers

Product-grade AI tool for tender evaluation: go/no-go scoring, commercial proposal generation, and tender document analysis. Go 1.26 backend + React/Vite/TypeScript. Clean Architecture, DDD, pluggable LLM with 5 providers and runtime switching.

5725 commits, 5636 of them mine (measured 30 Oct)

Architecture
Clean Architecture + DDD on Go 1.26: domain invariants in the domain layer, ports in usecase, adapters in infra. Pluggable LLM provider as a domain interface. Modular structure ready to scale. golangci-lint v2 with the modernize analyzer in CI
Backend
5 LLM providers (Anthropic Claude / OpenAI / Gemini / Groq / Ollama) with runtime switching from config. Rubric-based tender scoring (go/no-go), proposal generation from templates, tender document processing, two-stage prompt-injection protection
Infrastructure
Docker Compose, GitHub Actions CI/CD (build + race tests + linter), multi-stage builds. Local development in OrbStack. Versioning via ldflags
Tests
Table-driven tests, go test -race. Coverage of domain logic, LLM response parsing, scoring, and the usecase layer. Tests gate merges in CI

Go 61.8%TypeScript 36.4%Other 1.8%

  • Go 1.26
  • React
  • Vite
  • TypeScript
  • Clean Architecture
  • DDD
  • Anthropic SDK
  • OpenAI
  • Gemini
  • Groq
  • Ollama
  • Docker
  • GitHub Actions
  • golangci-lint

Private repository

Floq - AI Sales Assistantv0.118.0, 4 AI providers

Full-stack B2B CRM with AI-powered cold outreach, multi-channel sequences (Email + Telegram + phone), and automated lead qualification. Clean Architecture, DDD, 20 PostgreSQL migrations, 51 API endpoints.

731 commits (measured 30 Oct)

Architecture
Clean Architecture (handler → usecase → repository → domain), DDD with value objects (LeadStatus, Channel, OutboundStatus), port/adapter interfaces, compile-time interface checks, TxManager for transactions, DTO mapping without json tags in domain layer, 20 SQL migrations (golang-migrate), anti-corruption layers (ProspectReader, LeadCreator)
Backend
51 REST API endpoints on Go 1.26 + chi v5, JWT auth (access + refresh tokens), pluggable AI provider (Claude/OpenAI/Groq/Ollama) with runtime switching from DB, SMTP sending via mail.ru/Yandex/Gmail (TLS 465 + STARTTLS 587), IMAP polling for inbound emails (go-imap/v2), Telegram MTProto client (gotd/td) for personal account outreach, built-in email verifier (MX/SMTP probe/disposable filter), 2GIS API parser + website email scraper, AI chat assistant with DB context injection, prompt feedback loop, tracking pixel for open/reply tracking, cron-based follow-up system
Infrastructure
Docker Compose (PostgreSQL 18 + Redis 8 + Ollama + Backend), GitHub Actions CI/CD (Go build/test + Next.js lint/build), multi-stage Alpine image, OrbStack for local development
Tests
130+ unit tests across 16 packages (testify, race detector), coverage: auth (JWT middleware, token generation), AI client (extractJSON, prompt resolution, qualification parsing), email verification, settings DTO mapping, chat system prompt building

Floq vs SaaS Competitors

CapabilityApollo / Lemlist / Reply.ioFloq
Self-hosted / data ownershipNo - SaaS only, data on third-party serversFully on your server, Ollama = zero data leaks
Telegram outreach (personal account)No - Email + LinkedIn at mostMTProto via gotd/td - 900M+ audience, no spam filters
AI provider choiceOne built-in (usually OpenAI wrapper)4 providers with runtime switching from DB
AI learns from manager editsNo - static generationPrompt feedback loop: email quality improves over time
Cost$30–$160/mo per user$0 - self-hosted, pay only for API tokens

Go 58.4%TypeScript 40.1%SQL 1.5%

  • Go
  • Next.js 16
  • TypeScript
  • PostgreSQL
  • Redis
  • Docker
  • GitHub Actions
  • Tailwind CSS
  • shadcn/ui
  • chi
  • pgx/v5
  • JWT
  • SMTP
  • IMAP
  • Telegram MTProto
  • gotd/td
  • Anthropic SDK
  • OpenAI SDK
  • Groq
  • Ollama
  • golang-migrate

Private repository

Academic Secretary ISv0.223.0, in production

Modular monolith on Go: DDD + Clean Architecture, encapsulated domains. In-memory EventBus with Kafka abstraction. CQRS + Event Sourcing + Repository + Unit of Work. 22 PostgreSQL 17 SQL migrations. Results: Redis cache for hot reads via the Decorator pattern, monitoring from scratch, encrypted auto-backups, 189 releases in 4 months.

1640 commits

Architecture
Modular monolith on Go: DDD + Clean Architecture, CQRS, Event Sourcing, Repository + Unit of Work. In-memory EventBus with Kafka abstraction. gRPC interfaces. 22 PostgreSQL 17 SQL migrations with versioning and rollback
Backend
Gin: middleware chains, correlation IDs. OAuth 2.0 + JWT (full security claims, timing-attack prevention, bcrypt cost 14, rate limiting 5 req/15 min, 6 security headers). WebSocket chats. Predictive analytics. Composio Gmail API + Telegram Bot. 1C ERP integration. i18n ru/en/fr/ar with RTL
Infrastructure
Prometheus + Grafana (latency/error rate/throughput). Loki + Promtail (JSON logs). Grafana Tempo + OpenTelemetry (distributed tracing). Telegram alerts: CPU/RAM/Disk/API errors/backup. Docker + Docker Swarm. GitHub Actions CI/CD. Nginx + CloudFlare. Auto-backups PostgreSQL & MinIO with encryption
Tests
testify unit tests (Go), k6 load tests, Playwright E2E. AI-driven TDD: tests before implementation, parallel verification. Documentation: architecture, API reference, deployment, security. GitHub Projects: 40+ Issues. .taskmaster - AI-assisted task management

Redis - Performance

OperationNo cacheWith RedisImprovement
GetUserByID15–20 ms0.5–1 ms~25–30x faster
GetUserByEmail15–20 ms0.5–1 ms~25–30x faster

Decorator Pattern: zero changes to business logic. Invalidation by domain events - consistency guaranteed. Redis as session store and background job broker.

Go 52.7%TypeScript 44.2%Other 3.1%

  • Go
  • TypeScript
  • DDD
  • Event Sourcing
  • Redis
  • WebSocket
  • PostgreSQL
  • Docker
  • Docker Swarm

Code on GitHub

EstimateProv0.15.0, 145 tests

Collaborative project estimation platform. Modular Monolith + Clean Architecture + DDD on Go 1.26 and Next.js 16 with PostgreSQL 18, Redis 8, MinIO. Telegram bot Esti with LLM parsing and two-stage prompt protection architecture.

414 commits

Architecture
Modular Monolith with 7 modules (auth, project, document, estimation, notify, bot, ws). Clean Architecture: domain → usecase → handler. DDD: entities with business logic, sentinel errors, value objects. Adapters in composition root, zero cross-module imports. 8 PostgreSQL migrations via goose
Backend
57 REST endpoints (Chi router). JWT auth with token rotation in Redis. OAuth2 Google/GitHub. PERT estimation aggregation. WebSocket real-time. Telegram bot Esti: 4 LLM providers (Claude/OpenAI/Grok/Ollama), 12 intents, inline keyboards, conversation memory, two-stage architecture (classifier + personality formatter). Notifications: in-app + email + Telegram
Infrastructure
Docker Compose (PostgreSQL 18, Redis 8, MinIO, Go backend). GitHub Actions CI/CD. CORS allowlist, rate limiting (10 req/min on auth), MaxBodySize middleware, RequireProjectMember middleware for IDOR protection
Tests
145 test functions across 25 files. Table-driven tests, function-field mocks. Coverage: all usecases, domain logic, handlers, LLM providers, Telegram client (httptest), webhook, session flows. TDD for estimation (parser + aggregation)

EstimatePro vs existing solutions

FeaturePlanning Poker / Scrumpoker-onlineEstimatePro
PERT aggregation (min/likely/max)Only numeric voting or FibonacciThree-point PERT with automatic summary
Telegram bot with AINone - web interface onlyEsti bot: free text → LLM → action, 4 providers
Spec upload with versioningNo document supportPDF/DOCX/XLSX/MD/TXT/CSV in MinIO, versions, tags, signed/final
Self-hosted + Open SourceSaaS, data with providerAGPL-3.0, full data control, Docker Compose
Cost$5–25/mo per teamFree (self-hosted), only LLM API costs

Go 56.5%TypeScript 33.4%JSON 9.1%SQL 1%

  • Go 1.26
  • Next.js 16
  • TypeScript
  • PostgreSQL 18
  • Redis 8
  • MinIO
  • Chi
  • pgx
  • TanStack Query
  • Zustand
  • Tailwind CSS v4
  • shadcn/ui
  • Three.js
  • WebSocket
  • JWT
  • OAuth2
  • Docker
  • GitHub Actions
  • Claude API
  • OpenAI API
  • Ollama
  • Telegram Bot API

Code on GitHub

Lexisv0.17.0, 4 AI providers

AI-powered language tutor: Go modular monolith (Clean Architecture, DDD) + Next.js 16 frontend. 4 AI providers, SM-2 spaced repetition, JWT auth with token rotation, PostgreSQL, Redis.

148 commits

Architecture
Modular monolith (4 modules: auth, tutor, vocabulary, progress), layered domain → usecase → handler → infra. ProviderRegistry as domain interface. Auto-migrations via golang-migrate with embedded SQL. In-process event bus (pub/sub) for cross-module communication. RFC 7807 Problem Detail errors
Backend
JWT access/refresh token rotation with reuse detection and user-level blacklist via Redis. 4 AI providers (Claude, GPT-4o, Qwen, Gemini) with SSE streaming. SM-2 spaced repetition for vocabulary. 5 exercise modes (chat, quiz, translate, gap, scramble). Domain-level validation with sentinel errors
Infrastructure
Docker Compose (PostgreSQL 18, Redis 8). GitHub Actions CI: golangci-lint, go test -race, Next.js build, Playwright e2e. Ldflags version injection. MaxBodySize, RequireJSON, RateLimit (prefix-based, fail-closed for login) middleware
Tests
83 unit tests across 12 packages. Gomock for auth service, hand-written mocks for handler tests. Coverage includes: token rotation, SM-2 algorithm, goal progress, handler CRUD, eventbus concurrency, middleware auth. Playwright e2e for auth flow

Lexis vs Existing Solutions

CapabilityDuolingo / Anki / ChatGPTLexis
SM-2 + generative AIEither SR without AI (Anki) or AI without SR (ChatGPT)SM-2 algorithm + 4 AI providers in one system
Exercise modesDuolingo: templates / ChatGPT: chat only5 AI-generated modes: chat, quiz, translate, gap, scramble
AI model choiceLocked to one providerClaude, GPT-4o, Qwen, Gemini - no vendor lock-in
Self-hosted / privacyNo (except Anki without AI)Fully on your server, pay only for API tokens
CostDuolingo Max $30/mo, ChatGPT $20–200/mo$0 - self-hosted + your own API key

Go 60.5%TypeScript 34.2%YAML 3.3%SQL 1.1%CSS 0.9%

  • Go
  • Chi
  • PostgreSQL
  • Redis
  • JWT
  • Next.js 16
  • React 19
  • TypeScript
  • Zustand
  • Docker
  • GitHub Actions
  • Playwright
  • golang-migrate
  • pgx
  • bcrypt

Code on GitHub

kb-engine - Knowledge Base Engine (OSS)28 releases, 12 CI jobs

Open-source Go engine: CLI, terminal UI and an embedded React dashboard over a single usecase layer, so the surfaces cannot drift apart. 28 releases with binaries for six platforms and SBOMs. Kubernetes deployment (kustomize + a Helm chart) and infrastructure in Terraform. AGPL-3.0-or-later with a commercial alternative.

392 commits, 58k lines of Go, 246 test files (measured 30 Oct)

Architecture
Clean Architecture + DDD: a domain free of clocks and randomness, repository interfaces declared in the usecase layer. One rule lives in one place - terminal and web read through a shared query layer, so the views cannot disagree. Two architecture maps with file:line anchors verified by a validator in CI: the engine at 84 nodes and 48 scenarios, the cloud layer at 35 nodes and 8 scenarios
Backend
Catalog with integrity audits, link-health checks, and two-way jsonl ↔ xlsx sync plus duplicate protection right on the write path. Four-layer search: exact match, transliteration, edit distance, and a semantic layer over vector embeddings (1,487-entry index, bge-m3 model, service called over HTTP). The call was made by measurement: the semantic layer resolves one query in twelve, so no model was embedded into the binary - four direct dependencies and a 13.5 MB image stayed unchanged
Infrastructure
Kubernetes: kustomize (base plus overlays) and a Helm chart, both installed into one kind cluster in CI and compared by the objects in the cluster. Liveness and readiness probes are split deliberately: a corrupted catalog removes the pod from the Service without restarting it. Terraform: an S3 bucket with versioning and encryption, a read-only IAM role, state in the bucket with locking (verified by planting a foreign lock), tflint in CI. A /metrics endpoint in Prometheus format without a client library, plus Prometheus and Grafana with a dashboard as code. GitHub Actions, 12 jobs: race-detector tests, an 80% coverage floor, golangci-lint with modernize, govulncheck, CodeQL, gitleaks across the full history, and a dependency-age quarantine self-tested against a real incident. Verified against LocalStack and MinIO; real AWS and behaviour under load were not tested
Tests
189 test files with a coverage floor in CI. Every gate is tested against a planted violation

Go 71.3%TypeScript 24.6%Other 4.1%

  • Go
  • React
  • TypeScript
  • go:embed
  • Bubble Tea
  • Kubernetes
  • Helm
  • kustomize
  • Terraform
  • GoReleaser
  • SBOM
  • GitHub Actions

Code on GitHub

For developers: stack and code

The stack by level. Below is kb-engine in the browser.

  • In productionGo (chi, Gin, pgx), Python (FastAPI, SQLAlchemy, Alembic), PostgreSQL, Redis, Docker Compose, GitHub Actions, Prometheus, Grafana, Loki, Next.js, React, Vite, TypeScript
  • In my projectsKubernetes (kind in CI, Helm, kustomize), OpenTelemetry, Three.js, MCP servers (FastMCP)
  • FamiliarKafka (bus abstraction), gRPC
  • ApproachClean Architecture, DDD, TDD, CI gates
kb-engine in the browserEmulated on made-up data
kbengine version
kbengine v0.28.0 (go1.26, linux/amd64)
392 commits, 28 releases, binaries for 6 platforms, SBOM attached
Try:

All repositories on GitHub

Writing

Contact

Telegram is the fastest.