Alexander Soldatov
LLM Developer
5+ years exp
5+ years ML exp
SQL
Node JS
TypeScript
Python
Data Pipeline & Feature Engineering: 5/10
MLOps & Deployment: 5/10
Computational Efficiency: 4/10
Active 14 days ago
+7 (911) 0948730 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A backend-focused engineer at a Senior level who builds production-ready APIs and data-processing components. The strongest proven skill is building reversible RAG anonymization and vault-backed persistence with tests and atomic file handling (see lightanon_project/lightanon/rag/vault.py and tests/test_rag.py). Public artifacts do not show multi-service orchestration, migration histories for databases, or production-grade secrets management and auth flows.
Technical skills
SQL
Node JS• Senior
TypeScript• Middle
Python• Senior • 5y+
Node JS
Express
Python
FastAPI
Pydantic
Uvicorn
AI/ML
Embeddings
Fine-tuning
Hallucination
Keras
NumPy
Pandas
PyTorch
Reranking
Scikit-learn
Semantic Search
TensorFlow
XGBoost
Transformers
Bitsandbytes
Llama
NLP
Computer Vision• 5y+
AI Agents• 3y+
Claude• 3y+
Cursor• 3y+
LLM• 3y+
RAG• 3y+
Claude Code
Prompt Engineering
Frontend
React.js
Vite
Tailwind CSS
DevOps
Docker
Docker Compose
Git
Rest API
Prometheus
GCP
Mobile
MVP
Timeline
AI/LLM Expert (LLM Developer)
•
Middle
Terra AI / University of Artificial Intelligence
•
Full-Time
Develops neural-network software and designs AI solution architectures and educational AI tools. Builds LLM app and RAG scenario architectures, prepares learning materials on LLM/RAG/AI agents and prompt engineering, and supports adoption by training developers. Participates in testing AI coding assistants and contributes to practical assignments and implementation methodology.
LLM
RAG
AI Agents
Prompt Engineering
Cursor
Claude Code
Claude
AI Solution Architect / AI Tech Lead
•
Lead
II-Novye Stroitel'nye Resheniya (aihome)
•
Full-Time
Launched an AI direction and product line for the individual housing market, covering multiple AI products. Translated business hypotheses and product requirements into AI architecture, including LLM/RAG and multi-agent workflows, user scenarios, and backend logic with data-processing boundaries. Built and led a DS/Backend/Frontend/Testing/Support team, owned technical roadmaps and delivery quality, and introduced tools such as Cursor and Claude into daily development.
LLMsince 2023
RAGsince 2023
AI Agentssince 2023
Cursorsince 2023
Claude Codesince 2023
Claudesince 2023
Technical Director
•
Executive
UNILINE
•
Full-Time
Led the company’s IT direction and managed product and infrastructure initiatives, including systems integration and automation of business processes. Coordinated delivery of enterprise digital signage solutions, covering architecture of web/mobile components, ongoing support, and rollout. Implemented collection and analysis of product and operational metrics to guide further development.
Saint Petersburg State University of Water Communications
Doctoral Degree (PhD) •
Department of Computer Engineering (postgraduate studies for Automated Control Systems for Industrial Processes)
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
An experienced engineering-oriented LLM developer who produces production-ready inference and data-anonymization tooling. The strongest proven skill is reversible RAG-safe text sanitization and vault persistence demonstrated by lightanon/rag/sanitizer.py and lightanon/rag/vault.py (including atomic JSON flush and TTL handling). There is little to no evidence of custom training loops, experiment tracking, or quantified efficiency results for model optimization in public code.
Model Architecture & Training
2/10
How well models are designed and trained
Inference-focused model engineering (prompt formatting and 4-bit loading) but no custom training loops, loss/optimizer choices or training pipelines.
Evidence
Lora_bot/model.py:load_model_and_tokenizer
Lora_bot/model.py:build_llama3_prompt
Lora_bot/model.py:generate_answer
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Solid data-processing and anonymization pipelines for batch (pandas/polars) and rule-based transformations with domain-specific rules.
Evidence
lightanon/cli.py:_read_dataframe/_write_dataframe
lightanon/engine.py:Engine
lightanon/rules.py:Hash/Mask/Generalize
Experimentation & Evaluation
3/10
How results are measured and tested
Good unit and integration test coverage using pytest but no experiment tracking or hyperparameter/ablation workflows.
Evidence
tests/test_rag.py
tests/test_core.py
MLOps & Deployment
5/10
How models are shipped to production
Practical serving and deployment engineering - FastAPI service, health checks, Prometheus metrics and model startup/error handling.
Evidence
Lora_bot/app.py:FastAPI endpoints and metrics
Lora_bot/system_checks.py:check_nvidia_smi/check_torch_cuda
Lora_bot/model.py:device_map/load_in_4bit
Computational Efficiency
4/10
How efficiently computing resources are used
Explicit efficiency measures for inference (bitsandbytes 4-bit loading, device_map) and runtime checks, but no profiling or quantified before/after results.
Evidence
Lora_bot/model.py:AutoModelForCausalLM.from_pretrained(..., load_in_4bit=True)
Lora_bot/system_checks.py:check_bitsandbytes
Research Depth & Innovation
2/10
Depth of research and new ideas
Engineering-first work with careful implementation (reversible sanitization, atomic file writes) but no original research or novel algorithms.
Evidence
lightanon/rag/sanitizer.py:TextSanitizer (reversible tokenization, policies)
lightanon/rag/vault.py:FileVault atomic _flush and TTL handling
Expertise
RAG• Senior
LLM• Middle
Industries
Artificial Intelligence• Senior
Software• Middle
Technologies
SQL
Rest API
Claude• 3y+
Docker Compose
Claude Code
Bitsandbytes
XGBoost
Fine-tuning
Embeddings
Scikit-learn
Prompt Engineering
Computer Vision• 5y+
NLP
Llama
Transformers
TensorFlow
Pandas
NumPy
Keras
Git
PyTorch
Docker
RAG• 3y+
Hallucination
Reranking
Semantic Search
Recommendations
- Develop and maintain RAG sanitization and privacy-safe data pipelines for LLM ingestion, including vault-backed reversible anonymization.
- Build and operate LLM inference services with monitoring - production FastAPI endpoints, startup/runtime checks, and Prometheus metrics.
- Integrate dataset processing workflows for batch and streaming (pandas/polars + StreamEngine) and add profiling/quantified efficiency benchmarks.
- Extend to LLM system engineering tasks (RAG orchestration, cost/latency budgets, guardrails) where reversible sanitization couples with retrieval.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
A backend-focused engineer at a Senior level who builds production-ready APIs and data-processing components. The strongest proven skill is building reversible RAG anonymization and vault-backed persistence with tests and atomic file handling (see lightanon_project/lightanon/rag/vault.py and tests/test_rag.py). Public artifacts do not show multi-service orchestration, migration histories for databases, or production-grade secrets management and auth flows.
API Design
5/10
How well APIs are designed
Consistent API surface (CLI + HTTP endpoints) with response models and clear error handling, but limited evidence of versioning, idempotency key usage, or advanced API evolution strategies.
Evidence
SoldatovAlexander/lightanon_project/lightanon/cli.py:_run_rag_cli (CLI subcommands and argument parsing)
SoldatovAlexander/Lora_bot/app.py:POST /generate (FastAPI endpoint with Pydantic models and HTTPException usage)
SoldatovAlexander/BeSave/server.ts:/api/generate-news-text (Express endpoint with error handling and fallback logic)
Data Layer & Database
5/10
Working with databases
Thoughtful data-layer design for local persistence and mapping consistency (token<->value) with validation and TTL support, but no migration history or complex transactional DB work is present.
Evidence
SoldatovAlexander/lightanon_project/lightanon/rag/vault.py:FileVault._flush (atomic tempfile + os.replace) and JSON validation
SoldatovAlexander/lightanon_project/lightanon/rag/vault.py:TTL and metadata handling (expires_at, purge_expired)
SoldatovAlexander/BeSave/server.ts:Firestore usage (addDoc, query, deleteDoc, serverTimestamp)
Scalability & Performance
5/10
Handling load and speed
Performance-aware choices are visible - polars support for batch processing, 4-bit model loading and Prometheus metrics - but the code lacks explicit rate limiting, cache invalidation strategies, or documented queue-based decoupling.
Evidence
SoldatovAlexander/lightanon_project/requirements.txt:polars listed (polars>=0.19.0)
SoldatovAlexander/Lora_bot/model.py:AutoModelForCausalLM.from_pretrained(... load_in_4bit=True, device_map='auto')
SoldatovAlexander/Lora_bot/app.py:LLM_GENERATION_LATENCY Histogram and Instrumentator() Prometheus integration
System Architecture
5/10
Overall system structure
Module boundaries and abstractions (Engine, StreamEngine, RAG sanitizer and Vault interface) indicate deliberate separation of concerns, but there is no sign of multi-service coordination contracts or advanced distributed architecture decisions.
Evidence
SoldatovAlexander/lightanon_project/lightanon/__init__.py (package split into engine, stream, rag, financial, rules)
SoldatovAlexander/lightanon_project/lightanon/cli.py (CLI orchestrates Engine and RAG flows)
SoldatovAlexander/Lora_bot/app.py (separates system checks, model loading, endpoints and metrics)
Security & Auth
5/10
Protecting data and access
Security-aware patterns are present - input validation, vaults that avoid exposing values in stats, TTLs and purge semantics - but there is little evidence of authn/authz, secret-management hardening, or an explicit dependency vulnerability audit.
Evidence
SoldatovAlexander/lightanon_project/lightanon/rag/vault.py:_load and _validate_mapping (robust JSON validations and rejection of invalid formats)
SoldatovAlexander/lightanon_project/lightanon/rag/vault.py:stats (explicitly avoids including secret values in stats)
SoldatovAlexander/lightanon_project/lightanon/rag/sanitizer.py:policy checks in deanonymize (policy enforcement)
Reliability & Observability
6/10
Stability and monitoring
Good reliability and observability signals - unit tests covering many edge cases, health endpoints, Prometheus metrics, startup runtime checks, and safe atomic IO - though graceful shutdown, retries with backoff, or circuit-breaker patterns are not prominent.
Evidence
SoldatovAlexander/lightanon_project/tests/test_rag.py (extensive unit tests for sanitizer and vault lifecycle)
SoldatovAlexander/Lora_bot/app.py:/health and Prometheus metrics (LLM_REQUESTS_TOTAL, LLM_GENERATION_LATENCY)
SoldatovAlexander/Lora_bot/system_checks.py:_run (subprocess timeout) and assert_runtime_ready (startup checks)
Expertise
Backend AI & LLM• Senior
Python• Middle
Microservices & API Architecture• Middle
Node.js• Middle
Industries
Cybersecurity• Senior
Data & Analytics• Middle
Technologies
Python• Senior • 5y+
GCP
FastAPI
Prometheus
Pydantic
Uvicorn
Recommendations
- Lead development of RAG-safe pipelines and vault-backed anonymization services (reversible tokenization, TTL, audit) for LLM/knowledge base ingestion.
- Implement and operate LLM inference endpoints with observability and resource-aware loading (4-bit model loading, Prometheus metrics, health checks) using FastAPI or similar frameworks.
- Build Node.js-based AI-backed web services and the surrounding verification/grounding flows (safe parsing of model outputs, schema validation) for content generation products.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium App Engineer
A practical mid-level frontend/app engineer focused on building LLM-enabled web apps and server-client glue. The strongest proven skill is integrating LLMs and shaping server-to-client data flows, evidenced by the typed LLM response schemas and stream/fallback logic in llmService.ts and the generate-news-text pipeline in server.ts. Public code lacks an advanced component library, measurable performance audits, wide a11y coverage and end-to-end test suites.
UI Component Architecture
3/10
How interface parts are built
Basic component and styling artifacts exist (CSS, HTML) but there is little evidence of a crafted component architecture, design-system or non-trivial custom React component boundaries.
Evidence
Mira-Final/index.html: Tailwind-based layout and importmap wiring for UI libs
BeSave/src/index.css: theme tokens and base utilities (custom properties, no component library)
BeSave/vite.config.ts: project-level aliases and plugin setup (project UI wiring)
Responsive & Cross-browser
2/10
Works on all screens and browsers
Responsive design is present at a minimal level via Tailwind and viewport meta, but there is no evidence of advanced responsive strategies (container queries, RTL/i18n layout adaptations, feature detection).
Evidence
Mira-Final/index.html: meta viewport + Tailwind CDN and custom tailwind.config in script
BeSave/src/index.css: CSS variables and base styles (no explicit RTL or container query usage)
Performance Optimization
3/10
Speed of the interface
Some practical performance considerations appear (dev/prod modes, esbuild bundling, limiting DB queries, stream handling) but there is no measured performance work, profiling artifacts, or advanced code-splitting evidence.
Evidence
BeSave/package.json: build script using vite build + esbuild server bundling
BeSave/server.ts: Vite middleware in dev, static serving in prod and query(limit) to limit Firestore reads
BeSave/vite.config.ts: plugin configuration and HMR toggles
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility signals (lang attribute, semantic HTML shell) but no ARIA, focus management, keyboard handling or CI a11y tooling detected.
Evidence
Mira-Final/index.html: <html lang="en"> and semantic head/body structure
BeSave/src/index.css: selection and utility classes (no ARIA or focus management code)
State Management & Data Flow
5/10
Managing data in the app
Strongest area - server/client state and LLM data flows: there are typed schemas for LLM outputs, stream-based LLM handlers, localStorage state utilities, and server endpoints with verification and fallback logic showing deliberate server-state discipline and failure handling.
Evidence
AI-Marketing-Builder-/src/services/llmService.ts: generateContent with responseSchema, fallback, and error handling
BeSave/server.ts: /api/generate-news-text pipeline (DeepSeek try, Gemini fallback, verification, SVG generation) and /api/save-news with Firestore writes and cleanup logic
AI-Marketing-Builder-/src/services/storageService.ts: localStorage-based state utilities (save/get/clear variants and brief)
UX & Visual Polish
3/10
Look and feel quality
Visual polish is present in CSS tokens, glass effects and deliberate fonts/colors, but UX edge-case patterns (skeletons, undo, offline/resume flows) and measured perceived-performance improvements are not evidenced.
Evidence
BeSave/src/index.css: theme variables, selection, and no-scrollbar utilities
Mira-Final/index.html: glass-panel and glass-message-ai styles and Tailwind theme override
BeSave/src/data.ts: curated content and hero post that indicate content-driven UI design
Expertise
Frontend AI Integration• Middle
React• Middle
Industries
Cybersecurity• Middle
Professional Services• Middle
Sales & Marketing• Middle
Technologies
TypeScript• Middle
Node JS• Senior
Tailwind CSS
Express
React.js
Vite
Recommendations
- Lead development of LLM-driven feature pages and server-side generation pipelines that require typed response handling and streaming (implement endpoints like /api/generate-news-text).
- Build client applications that consume streamed LLM responses with robust state management and cancellation - ideal for chat, content builders, or AI-assistant panels.
- Own product features in cybersecurity or marketing domains where content generation, verification, and exports are core (improve verification, provenance, and audit logging).
- Harden frontend/backends for production: remove client-side exposure of secrets, add a11y patterns, and add tests and performance measurement (Lighthouse, bundle analysis).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: