Daniyar Mukhan

AI/ML • Senior • 20 years • Almaty, Kazakhstan • UTC+05:00 • In office, Partially remote • Work permits: Kazakhstan • Citizenship: Kazakhstan • English: B2 • Available now

Backend Developer

4+ years exp

Python

JavaScript

Node JS

TypeScript

SQL

Model Architecture & Training: 7/10

Data Pipeline & Feature Engineering: 6/10

Experimentation & Evaluation: 6/10

Active 1 day ago

Invite to interview

Download CVCV

Overview

Technical skills

Timeline

Roles

Overview

Senior-level generalist focused on Python and Go application development with an emphasis on a well-structured board-game engine and desktop GUI experience. The strongest proven skill is game engine design and test harnessing as shown by app/engine/rules.py and the extensive scenario tests under tests/ (tests/run_all.py and tests/harness/engine.py). There is little public evidence of production-grade cloud infrastructure, Kubernetes manifests, Terraform remote-state practices, or advanced CI/CD progressive delivery patterns.

Phone

Technical skills

Languages

Python

JavaScript

Node JS

TypeScript

SQL

Databases

PostgreSQL

MongoDB

Redis

Apache Kafka

FAISS

AI/ML

ChatGPT

NumPy

OpenCV

OpenAI Codex

ONNX Runtime

Claude Code

Other

Angular

Docker Compose

Vue.js

Grafana

CUDA

Docker

Git

Linux

Rest API

GitLab CI

Jaeger

WordPress

Embeddings

GitHub

Deep Learning

CI/CD

RabbitMQ

CI/CD

gRPC

Timeline

Astana IT University

Bachelor's Degree • Software Engineering

2026 Astana, Kazakhstan

Backend Developer • Middle

Intellect Dialog • Full-Time

Jun 2025 to Aug 2026 1 Year 2 Months Almaty Fully remote

Developed and maintained backend services for internal and client-facing products using Node.js, NestJS, and Express. Designed REST APIs and data processing for web and mobile clients. Built automation workflows in n8n with CRM integrations and Telegram/WhatsApp scenarios. Worked daily with PostgreSQL, MongoDB, Redis, Docker/Docker Compose, Linux, and Git.

Node JS

Nest.JS

JavaScript

Rest API

PostgreSQL

Redis

Docker

Docker Compose

Linux

Git

n8n

Python

Software Engineer (Industrial Practice) • Middle

JSC NK KTZ • Internship

Almaty In office

Completed industrial practice twice in the Almaty main network branch as a software engineer. Supported software development tasks assigned during the practice periods under the program’s internship structure. Gained hands-on experience working in a production environment relevant to the candidate’s software engineering background.

Software Engineer (Industrial Internship) • Junior

JSC NC KTZ • Internship

Almaty In office

Completed industrial internship as a software engineer in two separate placements during 2025 and 2026. Supported software engineering activities within the Almaty branch of the main network organization. Specific technologies and responsibilities were not detailed in the provided CV.

Senior AI/ML Engineer Confidence: High ML Engineer

ML engineer (Senior) specializing in face-recognition training and evaluation pipelines with a strong focus on FAISS-based retrieval and biometric verification. The strongest proven skill is building end-to-end face-recognition training and evaluation systems, demonstrated by the custom IR ResNet model implementation, ArcFace/AdaFace loss heads, distillation training loop, and LFW evaluation scripts. Public code lacks evidence of large-scale production deployment automation (Kubernetes/serving infra like Triton) and does not show formal experiment tracking integrations (W&B/MLflow) or privacy governance policies.

Model Architecture & Training

7/10

How well models are designed and trained

Strong custom training and model-building evidence: custom IR ResNet implementations, ArcFace/AdaFace loss heads, distillation and full training loops with checkpointing and validation.

Evidence

training/models/ir_resnet.py: InsightFaceIResNet / build_model usage

training/losses/arcface.py: ArcFace loss implementation

training/train_custom_distill_arcface.py: full custom training loop with GradScaler, optimizer, distillation

Data Pipeline & Feature Engineering

6/10

How data is prepared for models

Solid dataset and preprocessing pipelines with dataset classes and tooling for dataset preparation and distillation teacher caches.

Evidence

training/datasets/folder_dataset.py: FolderFaceDataset data loading

training/datasets/distill_face_dataset.py: DistillFaceDataset for teacher-student distillation

training/tools/prepare_celeba.py: dataset preparation utilities

Experimentation & Evaluation

6/10

How results are measured and tested

Thoughtful evaluation and experiment tracking: LFW evaluation scripts, pair parsing, metric computation, epoch metric dumps and markdown reports.

Evidence

scripts/evaluate_lfw_verification.py: end-to-end LFW evaluation and metrics generation

scripts/evaluate_torch_candidate_lfw.py: candidate checkpoint inspection and LFW evaluation

training/train_custom_distill_arcface.py: writes metrics_epoch_*.json and selection metrics

MLOps & Deployment

5/10

How models are shipped to production

MLOps and deployment engineering present: FAISS-backed index management, snapshotting with checksums and encryption, FastAPI runtime and pipeline registry for serving.

Evidence

backend/app/services/index/index_manager.py: snapshot save/load, atomic writes, pruning

backend/app/services/index/faiss_index.py: FAISS index wrapper for add/search/save/load

backend/app/main.py: FastAPI app wiring with pipeline registry and lifecycle

Computational Efficiency

6/10

How efficiently computing resources are used

Performance-aware engineering: FAISS benchmarking, use of CUDA/autocast/GradScaler, careful batching/caching and latency/memory measurement tooling.

Evidence

scripts/benchmark_retrieval.py: FAISS HNSW/IVFPQ benchmarking and latency/memory measurement

training/train_custom_distill_arcface.py: torch.amp autocast, GradScaler, DataLoader pin_memory and gradient clipping

Research Depth & Innovation

4/10

Depth of research and new ideas

Good applied research depth reproducing known biometric methods and evaluation protocols, but not introducing novel algorithms.

Evidence

training/losses/distillation.py: CosineEmbeddingDistillationLoss implementation

training/losses/adaface.py: AdaFace loss implementation

scripts/run_celeba_finetune_experiments.py: experimental protocol and LFW-based selection

Expertise

Computer Vision & Image Analysis• Senior

MLOps & Model Lifecycle• Senior

AI Infrastructure & Optimization• Middle

Industries

Artificial Intelligence• Middle

Technologies

Deep Learning

SQL

OpenCV

FAISS

Embeddings

NumPy

CUDA

ONNX Runtime

Recommendations

Develop production-grade face-recognition and embedding-serving systems that require FAISS-based retrieval, snapshotting and secure index management.
Build and maintain model training and evaluation pipelines for biometric systems, including distillation experiments and LFW-style verification evaluations.
Benchmark and optimize vector search and indexing configurations (HNSW, IVFPQ) and integrate latency/memory budgets into release criteria.
Implement secure model lifecycle features: encrypted snapshot rotation, automated reproducible training runs, and structured experiment tracking (W&B/MLflow).

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Fast-Face-Search-system tzfastapi CTS

Senior Backend Developer Confidence: High API Engineer

Backend engineer (Senior) focused on biometric face-search and embedding/vector retrieval systems with strong practical engineering. The strongest proven skill is building and operating vector search and embedding pipelines with FAISS and related tooling, supported by app/services/index/faiss_index.py and scripts/benchmark_retrieval.py. The public code does not show large-scale ops artifacts like multi-region deployment manifests, extensive CI/CD pipelines or Kubernetes orchestration.

API Design

5/10

How well APIs are designed

API layer is well-structured with dependency injection, route-level tests and consistent Pydantic schemas, but lacks explicit versioning and advanced idempotency patterns.

Evidence

buytheaway/Fast-Face-Search-system/backend/app/api/deps.py: get_db, get_pipeline_registry (dependency injection) buytheaway/Fast-Face-Search-system/backend/app/api/routes/search.py: search flow and error mapping buytheaway/Fast-Face-Search-system/backend/tests/test_routes.py: route-level integration tests

Data Layer & Database

6/10

Working with databases

Database layer shows deliberate schema evolution, typed models and repository abstractions with SQLAlchemy and Alembic migrations; transactional patterns and integrity checks are visible in repo code and tests.

Evidence

buytheaway/Fast-Face-Search-system/backend/app/db/migrations/versions/0001_init.py: initial schema migration buytheaway/Fast-Face-Search-system/backend/app/db/models.py: Declarative models (Person, Embedding, IndexSnapshot, AuditLog) buytheaway/Fast-Face-Search-system/backend/app/services/storage/repositories.py: PersonRepo / EmbeddingRepo with select/delete patterns and joinedload usage

Scalability & Performance

6/10

Handling load and speed

Performance and scalability work is explicit: FAISS integration, index snapshotting, benchmarking tooling and measurement of latency/memory tradeoffs are implemented and tested.

Evidence

buytheaway/Fast-Face-Search-system/backend/app/services/index/faiss_index.py: FaissIndex implementation (train/search/save/load) buytheaway/Fast-Face-Search-system/backend/app/services/index/index_manager.py: snapshot/save/rebuild/prune logic buytheaway/Fast-Face-Search-system/scripts/benchmark_retrieval.py: FAISS benchmarking and latency/top-k analysis

System Architecture

5/10

Overall system structure

Clear modular decomposition (runtime pipelines, index manager, storage repos, desktop client). Architecture is pragmatic rather than distributed-systems novel; inter-service contracts are limited to CLI/scripts and clear file-based snapshots.

Evidence

buytheaway/Fast-Face-Search-system/backend/app/services/runtime/pipeline_registry.py: Pipeline runtime registry and resolution buytheaway/Fast-Face-Search-system/backend/app/services/index/index_manager.py: service-level index management and snapshot semantics buytheaway/Fast-Face-Search-system/desktop/app/core/api_client.py: separation of desktop client API usage

Security & Auth

6/10

Protecting data and access

Security awareness is evident: AES-GCM payload encryption for snapshots, timing-safe API key comparisons and a rate limiter that avoids logging secrets; tests cover cryptographic roundtrips and edge cases.

Evidence

buytheaway/Fast-Face-Search-system/backend/app/security/crypto.py: encrypt/decrypt embedding and snapshot payloads using AESGCM buytheaway/Fast-Face-Search-system/backend/app/security/auth.py: classify_api_key with timing-safe comparisons buytheaway/Fast-Face-Search-system/backend/tests/test_security.py: tests for embedding payload roundtrip and rate-limiter rules

Reliability & Observability

5/10

Stability and monitoring

Reliability patterns exist: atomic snapshot writes, snapshot retention and tests for failure modes; logging setup and lifespan hooks are present but full observability (tracing, rich metrics) is lightweight in code shown.

Evidence

buytheaway/Fast-Face-Search-system/backend/app/services/index/index_manager.py: _write_atomic, _prune_old_snapshots, save/load snapshot safeguards buytheaway/Fast-Face-Search-system/backend/app/core/logging.py: logging setup entrypoint buytheaway/Fast-Face-Search-system/backend/tests/test_index_snapshot_retention.py: tests ensuring pruning and save failure behavior

Expertise

Python• Senior

Go Development• Middle

Microservices & API Architecture• Middle

Industries

Artificial Intelligence• Senior

Technologies

Rest API• since 2025

gRPC

WordPress

Recommendations

Develop FAISS-backed retrieval services and embedding pipelines (indexing, snapshot lifecycle, encrypted snapshots).
Implement/own backend APIs for ML-driven products including schema evolution and repository patterns (FastAPI + SQLAlchemy + Alembic).
Build benchmarking and performance tuning for vector search (latency, memory, indexing strategies).
Integrate desktop operator clients that consume backend APIs (PySide6 client + API client glue).

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Fast-Face-Search-system CATAN-GAME AIPass

Senior DevOps Engineer Confidence: High Generalist

CI/CD Pipelines

2/10

Automated build and deploy

Basic CI presence and pipelines for Go service (tests + docker builds) but no advanced reusable workflows, deploy gates, artifact signing or progressive delivery patterns.

Evidence

AIPass/.gitlab-ci.yml

AIPass/Makefile

Infrastructure as Code

1/10

Managing servers with code

Minimal infrastructure-as-code evidence; service composition via docker-compose is present but no Terraform/remote state/locking or multi-env stateful IaC modules.

Evidence

AIPass/docker-compose.yml

AIPass/Makefile

Containerization & Orchestration

2/10

Working with containers

Containerization is used (docker images, docker-compose, CI builds) but no orchestration manifests, Kubernetes, resource tuning, or production-grade helm/manifest templates.

Evidence

AIPass/docker-compose.yml

AIPass/.gitlab-ci.yml

Observability & Monitoring

3/10

Watching system health

Application-level telemetry and metrics scaffolding exists (Prometheus/Grafana/Jaeger mentioned and metrics/telemetry modules present) but no SLOs, burn-rate alerting or alert routing wiring are visible.

Evidence

AIPass/internal/metrics/metrics.go

AIPass/internal/telemetry/telemetry.go

AIPass/README.md

Reliability & Incident Response

2/10

Keeping systems up

Reliability practices are visible primarily via a substantial test harness and scenario tests for the game engine, but there is no evidence of deploy strategies (canary/blue-green), runbooks, or incident postmortems.

Evidence

buytheaway/CATAN-GAME/tests/run_all.py buytheaway/CATAN-GAME/tests/harness/engine.py

Cloud & Cost Optimization

1/10

Smart use of the cloud

Cloud/cost optimization artifacts are not present; services are run locally via docker-compose with no autoscaling, spot/eviction strategies or cloud cost measures.

Evidence

AIPass/docker-compose.yml

Expertise

Observability & Monitoring• Middle

Platform Engineering & IDP• Middle

Industries

Financial Services• Middle

Events & Ticketing• Middle

Media & Entertainment• Middle

Technologies

CI/CD

Go• since 2025 • Senior

Docker Compose• since 2025

Jaeger

GitLab CI

Grafana

Recommendations

Develop desktop GUI applications and interactive simulation engines (PySide6-based UIs and a deterministic game engine).
Build and extend backend microservices in Go with standard CI builds and container workflows (unit + integration tests, docker build pipelines).
Implement observability improvements: expose Prometheus metrics, add SLOs, and wire alerting/inhibition rules and example dashboards into CI for deployment.
Harden delivery pipelines: add reproducible artifact builds, deploy gates, and a simple progressive delivery pattern (canary or feature flags) for services.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

CATAN-GAME AIPass FinMasTen