Nikita Lapa

AI/ML • Senior • Fully remote • Available now

AI Engineer

Python

SQL

JavaScript

TypeScript

Computational Efficiency: 6/10

Data Pipeline & Feature Engineering: 5/10

Experimentation & Evaluation: 4/10

Invite to interview

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

Languages

Python

SQL

JavaScript

TypeScript

Python

Pydantic

aiogram

Asyncio

SQLAlchemy

Django

Aiohttp

Alembic

FastAPI

HTTPX

Frontend

React.js

Next.js

Tailwind CSS

Zod

shadcn/ui

Radix UI

Other

PostgreSQL

Redis

Claude

Kubernetes

Playwright

Pytest

SQLite

AI/ML

Supabase

Docker

GitLab CI

Vercel

Rest API

Vite

Claude Code

Cursor

K3s

HashiCorp Vault

Vault

PostCSS

ArgoCD

CI/CD

Docker Compose

Helm

GitOps

Kustomize

WebRTC

External Secrets

Senior AI/ML Engineer Confidence: Medium LLM Engineer

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:

podvalchik_bot nikito4kv stock-importer

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.

Evidence

nikito4kv/podvalchik_bot/app/core/scoring.py nikito4kv/podvalchik_bot/app/utils/leaderboard_data.py nikito4kv/podvalchik_bot/tests/test_leaderboard_data.py

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.

Evidence

nikito4kv/podvalchik_bot/app/scripts/migrate_sqlite_to_pg.py nikito4kv/podvalchik_bot/app/db/migration_v4_seasons.py nikito4kv/podvalchik_bot/app/db/crud.py

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.

Evidence

nikito4kv/Easy-Calendar/app/routes/statistics.py nikito4kv/podvalchik_bot/app/handlers/stats.py

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.

Evidence

nikito4kv/podvalchik_bot/app/core/scoring.py

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.

Evidence

nikito4kv/Easy-Calendar/app/models/lesson.py nikito4kv/Easy-Calendar/app/routes/api.py nikito4kv/podvalchik_bot/app/handlers/tournament_management.py

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.

Evidence

nikito4kv/podvalchik_bot/requirements.txt nikito4kv/podvalchik_bot/alembic/env.py nikito4kv/podvalchik_bot/tests/test_stats_handlers.py

Expertise

Data Science• Middle

Industries

Sports• Middle

Education• Middle

Technologies

Python• since 2025 • 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:

podvalchik_bot nikito4kv Easy-Calendar

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:

podvalchik_bot nikito4kv lawyer-crm