Artem Pronin
Node JS
Python
JavaScript
API Design: 6/10
Data Layer & Database: 6/10
System Architecture: 6/10
Active 1 day ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
Senior backend engineer focused on API-first services and media processing pipelines with strong practical experience in designing resilient integrations and background processing. The strongest proven skill is building robust multimedia processing backends and connectors as evidenced by the FastAPI pipeline, Celery tasks, and platform connectors in the shorts-studio Python project. Public code does not show a long migration history or large-scale multi-tenant production operator tooling such as SLO-driven alerting, extensive infra-as-code or enterprise-grade deployment automation.
Technical skills
Node JS• Senior
Python• Senior
JavaScript• Senior
Node JS
Express
Python
FastAPI
SQLAlchemy
Celery
Uvicorn
HTTPX
Pydantic
Requests
Databases
PostgreSQL
Redis
Frontend
Frontend
DevOps
Containers
Docker Compose
Nginx
Senior Backend Developer
Confidence: High API Engineer
Senior backend engineer focused on API-first services and media processing pipelines with strong practical experience in designing resilient integrations and background processing. The strongest proven skill is building robust multimedia processing backends and connectors as evidenced by the FastAPI pipeline, Celery tasks, and platform connectors in the shorts-studio Python project. Public code does not show a long migration history or large-scale multi-tenant production operator tooling such as SLO-driven alerting, extensive infra-as-code or enterprise-grade deployment automation.
API Design
6/10
How well APIs are designed
Consistent REST API design with input sanitization, pagination, idempotency for payment webhooks, explicit timeout handling and exportable internals for testing; lacks an explicit versioning strategy but shows deliberate error contracts and filter/pagination semantics.
Evidence
WhisperWink/src/server.js: routes and helpers including sanitizeText, parseEnumCsv, pagination and /api/vacancies endpoints
WhisperWink/src/server.js: verifyTributeWebhookSignature and idempotent payments handling in /api/tribute/webhook and /api/payments endpoints
shorts-studio/backend/app/api/router.py: FastAPI APIRouter endpoints and schemas usage
Data Layer & Database
6/10
Working with databases
Thoughtful data layer with SQLAlchemy models, session management, and tests asserting persistence and transactional behavior; Node service uses an atomic JSON file update pattern. No explicit migration chain visible in provided files but many DB integrity checks and tests are present.
Evidence
shorts-studio/backend/app/database/models.py: SQLAlchemy models and domain entities
shorts-studio/backend/app/database/session.py: session, engine and init_db patterns
WhisperWink/src/db.js: ensureDb, readDb, updateDb and atomic blob helpers
Scalability & Performance
5/10
Handling load and speed
Design includes background workers, Celery for heavy processing, timeouts and AbortController usage, and a channel watcher thread for scalable ingestion. Lacks visible end-to-end measured performance optimizations or cache invalidation policies in the provided excerpts.
Evidence
shorts-studio/backend/app/tasks.py: Celery integration and process_video_task
shorts-studio/backend/app/channel_watcher/service.py: threaded channel watcher and run_channel_cycle
WhisperWink/src/server.js: withTimeout and tributeShopRequest with AbortController and configured timeouts
System Architecture
6/10
Overall system structure
Clear module decomposition and plugin-style connectors for publishers, a distinct export pipeline, ingestion and scheduler subsystems, and a registry for platform connectors. Architecture shows deliberate boundaries and operational concerns such as resumable stages and dry-run publishing.
Evidence
shorts-studio/backend/app/export_pipeline/pipeline.py: staged pipeline and resume_interrupted_jobs
shorts-studio/backend/app/platform_connectors/registry.py: get_publisher registry and multiple platform implementations
shorts-studio/backend/app/scheduler/service.py: dispatch_due and recover_interrupted scheduling logic
Security & Auth
6/10
Protecting data and access
Good security practices are present: timing-safe comparisons for webhook signatures, verification of Telegram initData, use of Fernet for encrypting stored credentials, input sanitization and limiting of uploaded evidence sizes. Token lifecycle and revocation patterns are basic but present via auth helpers and protected endpoints.
Evidence
WhisperWink/src/server.js: verifyTributeWebhookSignature using timing-safe comparison and webhook verification
shorts-studio/backend/app/core/secrets.py: encrypt_credentials and decrypt_credentials using cryptography.Fernet
WhisperWink/src/auth.js: signAccessToken, authRequired and requireRole (authentication middleware)
Reliability & Observability
6/10
Stability and monitoring
Reliability is addressed by timeouts, careful startup ordering, resumable jobs, and many unit tests covering edge cases. Observability hooks such as structured logging are configured, though explicit alerting/metrics configuration is not visible in the analyzed files.
Evidence
shorts-studio/backend/app/main.py: startup lifecyle, resume_interrupted_jobs and error handling
shorts-studio/backend/app/core/logging.py: configure_logging with structlog usage and redaction
shorts-studio/backend/tests: multiple tests covering persistence, scheduler, and connector behavior (for example tests/test_persistence_contract.py and tests/test_scheduler.py)
Expertise
Node.js• Middle
Python• Senior
Microservices & API Architecture• Senior
Industries
Media & Entertainment• Senior
Technologies
PostgreSQL
Redis
SQLAlchemy
Uvicorn
Telegraf• mentioned only
Text• mentioned only
WPF• mentioned only
Recommendations
- Develop backend APIs that orchestrate heavy media pipelines and Celery workers, including clear operational runbooks for resuming and debugging jobs.
- Implement additional observability and SRE signals - metrics, SLI/SLO and alerting - around the export pipeline and scheduler for production readiness.
- Build secure OAuth connector integrations and payment webhook handlers with strong idempotency and replay protection for new third-party platforms.
- Design data migration histories and explicit migration scripts for SQL models so schema evolution is traceable and testable across deployments.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Frontend Developer
Confidence: High Fullstack
Fullstack web engineer specializing in practical Telegram Mini Apps and lightweight local-first services at a Senior level with strong end-to-end integration skills. The strongest proven skill is building resilient async ingestion and notification pipelines, evidenced by the telegram-channel-import.js import scanner and server.js import orchestration with timeouts and background notifications. The public code lacks formal test coverage and a documented CI pipeline, and the frontend is implemented in vanilla JS rather than a modern component framework which limits evidence of large-scale frontend architecture choices.
UI Component Architecture
3/10
How interface parts are built
Vanilla-JS UI with clear modular functions and composition for multi-selects and templates but no component framework or custom design-system; component boundaries are file/function-level rather than reusable component library.
Evidence
web/app.js: MULTI_SELECT_DEFS and JOB_MULTI_SELECT_DEFS driving UI composition and chips rendering
web/app.js: vacancyTemplate / myVacancyTemplate functions for view generation and separation of rendering logic
web/index.html: structured tab panels and ARIA attributes paired with setActiveTab in web/app.js
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive layout and basic accessibility-ready markup present, meta viewport and fluid layouts used; no advanced responsive features like container queries or explicit RTL/i18n strategy beyond basic localization strings.
Evidence
web/index.html: <meta name="viewport"> and grid-based layout with responsive classes
web/app.js: formatDateShort using toLocaleDateString for localized formatting and use of aria attributes in templates
Performance Optimization
5/10
Speed of the interface
Measured and pragmatic performance work on server-side imports and fetches, timeouts and caching; client implements pagination and incremental loading. Evidence of careful batching and abort handling for network operations.
Evidence
src/server.js: withTimeout and refreshTelegramImportsForFeed that serves requests while background import runs and re-notifies when ready
src/telegram-channel-import.js: findLatestPostId, scanHighestExistingPostId and fetchWidgetHtml using AbortController and caching to limit fetches and windowed scanning
Accessibility & Semantics
4/10
Usable for everyone
Reasonable accessibility and semantics: aria attributes, keyboard-accessible star rating, and focus/aria-selected handling on tabs. Not a complete accessibility audit but deliberate accessibility signals are present.
Evidence
web/index.html: aria-labels on chips and star input, alt attributes and semantic structure
web/app.js: setActiveTab sets aria-selected and toggles hidden, reviewStarInput uses buttons with aria-labels
State Management & Data Flow
5/10
Managing data in the app
Solid state and server-state discipline across client and server: auth refresh with retry, idempotent webhook handling, atomic DB updates and background syncs with timeouts and rescue logic; no central complex state machine but clear async/race handling.
Evidence
web/app.js: api() auto-refresh pattern with refreshAuthToken and authRefreshPromise to avoid duplicate auth flows
src/server.js: Tribute webhook idempotency checks, verifyTributeWebhookSignature and updateDb usage for atomic updates
src/telegram-channel-import.js: ensureTelegramChannelImportsFresh and activeSyncPromise to avoid concurrent syncs
UX & Visual Polish
5/10
Look and feel quality
Thoughtful UX: explicit empty/error states, toast feedback, pagination and progressive loading; forms include validations and informative error messages. Visual polish exists but built with vanilla JS rather than a component system.
Evidence
web/app.js: showToast and many user-facing error/success flows (publishListing, loadVacancies, sendReview)
web/app.js: loadVacancies implements pagination, empty state markup and graceful error fallback
Industries
Internet Services• Middle
Media & Entertainment• Middle
Technologies
Frontend
JavaScript• Senior
Node JS• Senior
Express
Telegraf• mentioned only
Recommendations
- Build Telegram Mini Apps and bots that need robust import, parsing and notification pipelines including webhooks and payment flows.
- Implement BFF-style APIs for small-to-medium consumer web apps that require careful idempotency, webhook verification and background syncs.
- Lead development of content-moderation and ingestion tooling that requires heuristics, deduplication and rate-limited remote fetches.
- Prototype UX-driven frontend features and small SPAs where vanilla JS is acceptable, or migrate to a component framework when reusable component boundaries and tests are required.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior DevOps Engineer
Confidence: High Generalist
Senior-level full-stack Python developer specializing in local-first video processing and automated publishing pipelines. The strongest proven skill is building robust clip scoring and adaptive scheduling logic as implemented in app/clip_scoring/service.py and app/api/router.py. Public code shows strong application and test coverage but lacks production CI/CD pipelines, cloud IaC, and Kubernetes-level orchestration artifacts.
CI/CD Pipelines
2/10
Automated build and deploy
Minimal CI/CD artifacts: Dockerfiles and docker-compose present but no reusable workflows, pipeline gating, artifact signing or marketplace-action engineering.
Infrastructure as Code
1/10
Managing servers with code
Little to no infrastructure-as-code; a docker-compose development stack exists but no remote state, Terraform/Pulumi modules, or environment-isolated IaC.
Containerization & Orchestration
4/10
Working with containers
Solid containerization for app and frontend with multistage builds and healthchecks, but no orchestration manifests, resource tuning for Kubernetes, PDBs, or non-root/container security hardening.
Observability & Monitoring
2/10
Watching system health
Basic observability: logging configuration and health endpoint exist, but no SLOs, burn-rate alerts, structured telemetry pipelines or alert routing as code.
Reliability & Incident Response
5/10
Keeping systems up
Good reliability and operational thinking inside the application: atomic operations, job resume/dispatch, scheduler with conflict checks, library of tests covering edge cases and failures; limited evidence of runbook/DR rehearsal or deployment rollbacks.
Evidence
EdryStarz/shorts-studio/backend/app/api/router.py: _start_or_resume_processing and schedule_autopilot_pool with slot validation
EdryStarz/shorts-studio/backend/app/local_director/service.py: _ensure_runtime with threading lock and safe download/extract
EdryStarz/shorts-studio/backend/tests/test_publishing_queue.py: extensive tests for scheduling, gap/window validation and recovery scenarios
Cloud & Cost Optimization
1/10
Smart use of the cloud
Little to no cloud cost or capacity optimisation demonstrated; connectors to cloud-hosted APIs exist but no autoscaling, spot/eviction handling, or IAM least-privilege patterns are visible.
Expertise
Site Reliability Engineering• Middle
Industries
Media & Entertainment• Middle
Technologies
Containers
Python• Senior
Docker Compose
FastAPI
Nginx
Celery
Pydantic
HTTPX
Requests
Tkinter• mentioned only
Recommendations
- Lead development of local-first media ingestion and processing pipelines, including clip scoring, reframing and export (use app/clip_scoring/service.py and export pipeline as starting points).
- Implement reliable deployment pipelines and promotion gates (CI workflows, reusable actions, artifact signing) to bring the existing docker-compose stack to a production-grade delivery process.
- Extend operational hygiene: add SLOs/alerting as code, structured telemetry and runbooks for scheduler and worker incidents to formalize on-call and recovery procedures.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: