Nikita Lapa
AI Engineer
SQL
JavaScript
TypeScript
Python
Computational Efficiency: 6/10
Data Pipeline & Feature Engineering: 5/10
Experimentation & Evaluation: 4/10
Active 22 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A Senior software engineer focused on building production-grade asynchronous Python services and conversational bots with solid system design and testing. The strongest proven skill is architecting resilient async pipelines and concurrency-safe media ingestion (evidence: ParagraphMediaPipeline, BoundedExecutor/backpressure and the manifest/orchestrator design). The codebase does not include custom model training, SOTA research implementations, or full experiment tracking for model development.
Technical skills
SQL
JavaScript
TypeScript
Python• Senior
Python
aiogram
Aiohttp
Alembic
Asyncio
FastAPI
HTTPX
Pydantic
SQLAlchemy
Django
Databases
PostgreSQL
Redis
SQLite
Supabase
AI/ML
Claude
Claude Code
Cursor
AI/ML
DevOps
ArgoCD
CI/CD
Docker
Docker Compose
External Secrets
GitLab CI
GitOps
Helm
K3s
Kubernetes
Kustomize
Vercel
WebRTC
Rest API
Cybersecurity
HashiCorp Vault
Cryptography
Vault
Frontend
Next.js
React.js
shadcn/ui
Tailwind CSS
Vite
Zod
Radix UI
PostCSS
QA
Playwright
Pytest
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
A Senior software engineer focused on building production-grade asynchronous Python services and conversational bots with solid system design and testing. The strongest proven skill is architecting resilient async pipelines and concurrency-safe media ingestion (evidence: ParagraphMediaPipeline, BoundedExecutor/backpressure and the manifest/orchestrator design). The codebase does not include custom model training, SOTA research implementations, or full experiment tracking for model development.
Model Architecture & Training
1/10
How well models are designed and trained
No custom model architectures or training loops; mostly API/client integration for hosted GenAI models.
Evidence
stock-importer/services/genai_client.py: create_gemini_model
podvalchik_bot/requirements.txt: openai entry
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Solid data/ingestion and feature pipeline design for media/intent extraction and query building; clear layering and modular services.
Evidence
stock-importer/pipeline/intents.py: ParagraphIntentService
stock-importer/legacy_core/ingestion.py: ingest_script_docx / read_script_paragraphs
stock-importer/pipeline/media.py: ParagraphMediaPipeline.create_manifest/_build_slots
Experimentation & Evaluation
4/10
How results are measured and tested
Reasonable observability and evaluation scaffolding - perf contexts, event logging and test coverage for metrics/observability.
Evidence
stock-importer/pipeline/perf.py: PerformanceContext
stock-importer/services/logging.py: JsonLinePerfLogger
stock-importer/tests/test_phase0_observability.py
MLOps & Deployment
4/10
How models are shipped to production
Practical MLOps-like and release concerns - bootstrap/containerization, portable build, run orchestration and manifest persistence, but not model serving.
Evidence
stock-importer/app/bootstrap.py: ApplicationContainer / bootstrap_application
stock-importer/release_tools/portable.py: build_portable_bundle
stock-importer/pipeline/orchestrator.py: RunOrchestrator.execute
Computational Efficiency
6/10
How efficiently computing resources are used
Clear engineering for computational efficiency - backpressure, bounded executors, concurrency limits, deduplication and retry profiles.
Evidence
stock-importer/pipeline/backpressure.py: BoundedExecutor
stock-importer/pipeline/media.py: _effective_concurrency_limits and AssetDeduper
stock-importer/services/retry.py: build_retry_profile / compute_retry_delay_seconds
Research Depth & Innovation
1/10
Depth of research and new ideas
Little to no research-style artifacts - no custom layers, paper reproductions or training experiments present.
Evidence
stock-importer/pipeline/media.py: VideoSelectionPolicy and AssetDeduper (system design but not research/paper implementation)
Expertise
Conversational AI & Chatbots• Middle
AI Infrastructure & Optimization• Middle
Industries
Media & Entertainment• Middle
Sports• Middle
Technologies
AI/ML
SQL
Supabase
Cursor
Rest API
Claude
Docker Compose
Claude Code
Helm
Vercel
WebRTC
FastAPI
K3s
Kustomize
GitLab CI
CI/CD
GitOps
ArgoCD
SQLite
Docker
Kubernetes
Pydantic
HTTPX
External Secrets
Gemini• mentioned only
Recommendations
- Develop production conversational agents and Telegram bot backends - FSM, async DB interactions, notification/broadcast flows and robust error handling.
- Build and harden AI orchestration and ingestion infrastructure - RAG/agent orchestration, GenAI adapters, backpressure and retry profiles.
- Implement MLOps pipelines around model evaluation and experiment tracking (W&B/MLflow) and extend perf logging into experiment baselines.
- Lead work to scale media ingestion/download pipelines and reliability testing (deduplication, timeouts, storyblocks/backends resilience).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Data Scientist
Confidence: Medium Data Engineer
A backend-focused developer at a solid middle level who builds async Telegram bots and medium-sized Flask web services with relational schemas and migrations. The strongest proven skill is building production-ready application logic and data workflows - evidenced by the async bot handlers, SQLAlchemy models and Alembic migrations (for example app/handlers/tournament_management.py, app/db/models.py and alembic/env.py). There is limited evidence of statistical methodology, machine learning, or high-scale distributed data systems in the public code.
Statistical Rigor
2/10
Correct use of statistics
Basic heuristic scoring and leaderboard logic present but no formal statistical inference, uncertainty quantification or hypothesis-driven analysis.
Data Wrangling & Cleaning
4/10
Preparing and cleaning data
Clear DB migration and migration-helper scripts, CRUD layer and async session usage show practical data handling and migration experience.
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
Dashboard data endpoints and server-side chart data preparation exist, but exploratory analysis is limited to structured summary generation rather than narrative EDA.
Predictive Modeling
1/10
Building models that predict
No predictive modeling or ML pipeline evidence; scoring logic is application-specific rules rather than learned models.
Business Insight & Impact
3/10
Turning analysis into business value
Business rules and impact-aware logic (salary/rate calculations, forecast bonuses, broadcast notifications) are implemented, but there is limited explicit product-metric reasoning or cost/impact analysis.
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Project includes pinned requirements, automated DB migrations, and a substantial test suite indicating reproducibility and CI-friendly hygiene.
Expertise
Analytics• Middle
Industries
Sports• Middle
Education• Middle
Technologies
Python• Senior
Redis
SQLAlchemy
Django
Asyncio
Alembic
aiogram
Flask• mentioned only
Recommendations
- Develop and maintain async, database-backed Telegram bots and related backend services (bot flows, notification broadcasting, scoring rules).
- Implement and extend application-level analytics and reporting endpoints for product dashboards and small-to-medium sized data workloads.
- Build and operate migration and ETL utilities to move data between databases (SQLite -> Postgres) and maintain schema evolution using Alembic.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: High API Engineer
A backend-focused engineer building a production-grade Telegram bot and related backend services at about a mid-senior level. The strongest proven skill is robust async backend work around messaging and persistence - evidenced by async SQLAlchemy + Alembic migration chain (migration_v1..v6), carefully written handlers (tournament_management, prediction) and tests. What is not evidenced is multi-service distributed system design, advanced infra (Kubernetes/CI/CD pipelines) or formal API versioning/idempotency strategies.
API Design
4/10
How well APIs are designed
Design is consistent for Telegram callback-based API - clear callback-data conventions and reusable keyboard builders, but there is no API versioning, no explicit idempotency keys on potentially repeated actions, and error/response contracts are application-level (bot messages) rather than a formal API contract.
Evidence
app/handlers/prediction.py:callback-data conventions and use of tournament_selection_kb/select_tournament_* flows
app/keyboards/inline.py:view_forecast_kb, tournament_selection_kb and confirmation_kb define callback schema
app/handlers/tournament_management.py:use of confirmation_kb and predictable callback patterns for actions (tm_publish_, tm_close_bets_, etc.)
Data Layer & Database
6/10
Working with databases
Solid data layer usage: async SQLAlchemy session setup, multiple Alembic migration revisions (schema evolution), selectinload/joinedload to avoid N+1, explicit commits/refresh and transaction rollback on failure; isolation-level or advanced concurrency tuning not exposed.
Evidence
app/db/session.py:async engine and async_sessionmaker initialization (create_async_engine / async_sessionmaker)
alembic/versions/f2c27d06c3bc_initial_migration_with_biginteger.py and app/db/migration_v1.py..migration_v6_max_streak.py:multiple migration scripts showing schema evolution
app/handlers/tournament_management.py:selectinload usage when loading Tournament.participants/forecasts and transactional commit/rollback around results processing
Scalability & Performance
5/10
Handling load and speed
Practical scalability considerations present - background tasks for broadcasts, throttling (small sleep between messages), chunking messages to respect platform limits and usage of async DB sessions; no service-wide caching/invalidation or measured performance artifacts.
Evidence
app/handlers/tournament_management.py:notify_users_about_new_tournament creates a background task with asyncio.create_task and uses broadcast_message
app/utils/broadcaster.py:throttled broadcasting with asyncio.sleep and handling TelegramRetryAfter/TelegramForbiddenError
app/handlers/prediction.py & app/handlers/tournament_management.py:chunking/partitioning of long messages and split_text_chunks usage to handle Telegram limits
System Architecture
5/10
Overall system structure
Modular monolith with clear module boundaries (handlers, core, db, utils, scripts), FSM state separation and background job separation; not decomposed into multiple microservices and no advanced secret/config orchestration visible.
Evidence
main.py:application wiring - init_db, middleware, scheduler and RedisStorage wiring
project structure: app/handlers, app/db, app/core, app/utils, app/scripts - deliberate modular layout
app/core/scheduler_tasks.py and app/scripts/migrate_seasons.py:separation of scheduled/background work and migration scripts
Security & Auth
4/10
Protecting data and access
Security-aware in places - middleware to resolve users, pydantic-based config for settings, omission of tokens in export logic in frontend code; however there is broad except Exception usage in places, no detailed token lifecycle/refresh mechanics, and no evident automated dependency vulnerability scanning.
Evidence
app/middlewares/auth.py:AuthMiddleware resolving users from DB for request context
app/config.py:Settings implemented via pydantic-settings for centralized config handling
app/utils/temp_media.py and lawyer-crm/src/lib/telegram.js:explicit decision to not export bot token in backups and timeout/abort handling on outbound requests
Reliability & Observability
6/10
Stability and monitoring
Good reliability and observability practices - structured logging, careful handling of Telegram callback-answer edge cases, retries/timeouts for external calls, session rollback on critical errors, and unit tests covering handlers/utilities.
Evidence
app/handlers/stats.py:answer_callback_safe handling TelegramBadRequest/TelegramNetworkError and structured logging patterns (LOGGER.info/warning/error)
app/handlers/tournament_management.py:try/except around critical DB update with session.rollback() and logging.error(..., exc_info=True)
tests/test_telegram_media.py and tests/test_stats_handlers.py:unit tests for retry/timeout and callback handling behaviors
Expertise
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Industries
Sports• Middle
Technologies
PostgreSQL
Aiohttp
aiogram• mentioned only
Recommendations
- Use this developer to build and maintain async backend services for chatbots and real-time notification systems integrating SQL databases and Redis-backed FSM storage.
- Task the developer with extending data models and migration chains (Alembic) and writing server-side business logic that requires careful DB transactions and batch notifications.
- Assign them to implement observability and operational hardening - structured metrics, bounded retries with backoff/jitter, and safer exception handling (narrower except clauses).
- Have them design and harden broadcast/notification subsystems (rate limits, backpressure, and retry/circuit-breaker logic) for scale.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: