Gleb Bolezin
Node JS
Python
Data Pipeline & Feature Engineering: 5/10
Model Architecture & Training: 4/10
Research Depth & Innovation: 4/10
Active 11 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A developer who builds algorithmic and numerical libraries with strong correctness focus and solid test coverage, operating at a senior algorithmic level. The strongest proven skill is mathematical algorithm implementation and validation, evidenced by the simplex/gnomory/branch-and-bound modules and comprehensive pytest suites comparing results to SciPy and PuLP. There is little or no evidence of production backend concerns like databases, distributed services, deployment/config management or runtime observability beyond test-driven validation.
Technical skills
Node JS• Middle
Python• Senior
Node JS
Axios
AI/ML
NumPy
Pandas
Scikit-learn
TF-Keras
Streamlit
Frontend
Next.js
React.js
Tailwind CSS
React Router
React Hook Form
Socket.IO
Turborepo
ESLint
Senior AI/ML Engineer
Confidence: Medium ML Engineer
A technically capable ML engineer with proven independent development of non-trivial numerical and ML components. The strongest proven skill is algorithmic implementation for optimization - evidenced by dual_simplex, gomory_simplex and a branch-and-bound solver alongside thorough pytest suites validating correctness. There is limited evidence of production MLOps, experiment tracking, GPU/distributed training, or model lifecycle/versioning in public code.
Model Architecture & Training
4/10
How well models are designed and trained
Custom model definitions and a small training utility are present (TF/Keras-based), with explicit loss/optimizer construction and a demo training loop, but there is no evidence of production-grade training orchestration, distributed/GPU tuning or experiment tracking.
Evidence
kps-1/kps1/models.py: build_fnn, build_cfnn
kps-1/kps1/training.py: make_optimizer, make_loss, train_with_backprop_demo
kps-1/main.py: training orchestration and metric computations (_rmse/_mae/_r2)
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Well-structured feature engineering and dataset handling with reusable primitives and a custom feature application pipeline, plus example scripts demonstrating feature creation.
Evidence
kps-1/kps1/feature_engineering.py: CustomFeature, apply_custom_features, suggest_interesting_features
kps-1/kps1/data.py: Dataset class, load_ftball_dataset, apply_dataset_custom_features
kps-1/examples_feature_engineering.py: example_* functions showing usage
Experimentation & Evaluation
3/10
How results are measured and tested
There are experiment-record dataclasses and plotting utilities and a comprehensive pytest suite for the numerical algorithms, but no integrated experiment tracking (W&B/MLflow) or reproducible experiment manifests.
Evidence
kps-1/kps1/experiments.py: ExperimentRecord and record_to_dict
kps-1/kps1/viz.py: plot_training_curves, plot_backprop_gradients
simplex/tests/: extensive pytest comparisons against SciPy and PuLP
MLOps & Deployment
2/10
How models are shipped to production
Interactive demo UIs via Streamlit are provided for several tools which is useful for prototyping, but there is no evidence of serving infrastructure, model versioning, serialization, CI/CD for models or monitoring/drift detection.
Evidence
simplex/main.py: Streamlit UI for simplex/Gomory/BnB solver
kps-1/main.py: Streamlit orchestration for training/visualization
Computational Efficiency
3/10
How efficiently computing resources are used
Algorithmic implementations show attention to numeric correctness (use of Fraction) and pragmatic pivot/anti-cycling choices, but there is no evidence of GPU utilization, batching, quantization, or measured profiling/optimization.
Evidence
simplex/simplex/dual.py: uses fractions.Fraction for exact arithmetic and Bland's rule references
simplex/simplex/gomory.py: Fraction-based cuts and tableau history management
simplex/simplex/bnb.py: recursive BnB with pruning and tree construction
Research Depth & Innovation
4/10
Depth of research and new ideas
Implements non-trivial, domain-specific algorithms (dual simplex, Gomory cuts, branch-and-bound) correctly and with tests, demonstrating solid algorithmic understanding though not publishing novel research innovations.
Evidence
simplex/simplex/gomory.py: gomory_simplex implementation with cut generation and dual-phases
simplex/simplex/bnb.py: branch_and_bound and solve_integer with tree representation
simplex/simplex/dual.py: dual_simplex, pivot and solution extraction utilities
Expertise
MLOps & Model Lifecycle• Middle
Industries
Sports• Middle
Technologies
Scikit-learn
Pandas
NumPy
TF-Keras
Streamlit
Recommendations
- Develop interactive numerical/optimization tools and prototypes (solvers, visualizers) where correctness and UI demos matter - use the existing Streamlit frontends and tableau history infrastructure.
- Build ML prototypes that need careful feature engineering and custom training loops - leverage the feature_engineering and training modules to produce end-to-end experiments.
- Implement algorithmic components for operations research or combinatorial optimization libraries (simplex variants, cutting planes, BnB) and contribute to test-driven numeric packages.
- Expand into production model lifecycle work by adding model serialization, reproducible experiment tracking (W&B/MLflow), and CI/CD for model training and serving.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: Medium Generalist
A developer who builds algorithmic and numerical libraries with strong correctness focus and solid test coverage, operating at a senior algorithmic level. The strongest proven skill is mathematical algorithm implementation and validation, evidenced by the simplex/gnomory/branch-and-bound modules and comprehensive pytest suites comparing results to SciPy and PuLP. There is little or no evidence of production backend concerns like databases, distributed services, deployment/config management or runtime observability beyond test-driven validation.
API Design
3/10
How well APIs are designed
Library-level API design is consistent and well-tested (clear function signatures and backwards-compatible parameter choices), but there is no explicit versioning, error-contract standard or API documentation beyond tests and minimal UI glue.
Evidence
simplex/simplex/gomory.py: gomory_simplex(c, A, b, senses=None) signature and docstring
simplex/main.py: UI calls dual_simplex, gomory_simplex and solve_integer with consistent parameters
simplex/tests/test_simplex.py: uses simplex(...), dual_simplex(...) to validate external API behavior
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
3/10
Handling load and speed
The code contains algorithmic performance considerations (use of rational Fractions, Bland's rule to avoid cycling) and test comparisons against optimized solvers, but there are no production scalability patterns (caching, connection pooling, queueing, or load-testing artifacts).
Evidence
simplex/simplex/gomory.py: uses fractions.Fraction and dual/primal phases with careful pivot logic
simplex/tests/test_simplex.py: regression and comparative tests against SciPy/PuLP to validate correctness and numerical behavior
System Architecture
3/10
Overall system structure
Code is modular and decomposed into algorithmic components (dual, gomory, bnb) with a small, deliberate package layout; however this is a single-process algorithm library without multi-service decomposition, deployment, or secret/config management patterns.
Evidence
simplex/simplex/__init__.py: exposes components (dual, bnb, gomory) indicating module boundaries
simplex/simplex/bnb.py and simplex/simplex/dual.py: separate modules for branch-and-bound and simplex logic
Security & Auth
1/10
Protecting data and access
Minimal boundary validation and defensive checks exist (UI sanitizing and some try/excepts), but there is no evidence of authentication/authorization, secret management, dependency auditing or explicit mitigation for common backend security issues.
Evidence
simplex/main.py: defensive try/except in constraint formatting and cautious float conversions from UI inputs
simplex/tests/test_simplex.py: tests that validate input sign handling and that invalid signs raise errors
Reliability & Observability
4/10
Stability and monitoring
Good automated test coverage for many edge cases (degeneracy, unbounded, infeasible, rational coefficients) and deliberate return of status codes/objects for downstream handling; observability and runtime resilience (structured logs, timeouts, retries, graceful shutdown) are not present.
Evidence
simplex/tests/test_simplex.py: extensive pytest cases covering cycling, degenerate/rational cases and SciPy/PuLP comparisons
simplex/tests/test_gomory.py: integration-style tests comparing Gomory cuts against PuLP and asserting statuses
simplex/simplex/gomory.py: preserves and appends history in tableaux for debugging and analysis
Expertise
Python• Senior
Microservices & API Architecture• Junior
Technologies
Python• Senior
Recommendations
- Develop numeric/optimization libraries or algorithmic components (LP/MIP solvers, cut/branch-and-bound engines) where correctness and mathematical rigor are primary requirements.
- Implement computational backends or microservices that expose proven optimization algorithms (e.g., an optimization-as-a-service RPC layer) while pairing with engineers who handle production ops concerns.
- Work on algorithm-heavy features in analytics or operations-research teams, including test-driven implementations and solver integrations.
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 pragmatic frontend application engineer at a middle level who independently implements end-to-end client features for web apps. The strongest proven skill is building real-time and interactive features - exemplified by the WebRTC manual connection implementation and the chat create/edit flows that manage FormData, file previews and API interactions. The public code lacks evidence of automated tests, advanced state-machine patterns, measured performance optimization and formal accessibility/a11y testing infrastructure.
UI Component Architecture
3/10
How interface parts are built
Componentization exists at the page and small-component level but there is limited evidence of a deliberate design-system authored by the developer or advanced composition patterns; many pages reimplement similar UI logic (create/edit chat).
Evidence
JukNavozn1k/Glebogram/frontend/src/pages/Chats/Create.js: ChatsCreate component splitting UI and member-selection
JukNavozn1k/Glebogram/frontend/src/pages/Chats/Edit.js: ChatsEdit component with similar structure to Create (indicating reusable patterns could be extracted)
JukNavozn1k/Glebogram/frontend/src/pages/Auth/Paraphrase.js: self-contained feature component managing inputs and tabbed UI
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive layout is used through Tailwind utility classes and media-aware grids; cross-browser considerations appear at the feature level (video attributes), but there is no evidence of advanced fluid/RTL or feature-detection strategies.
Performance Optimization
2/10
Speed of the interface
Little evidence of measured or explicit performance work - no bundle analysis, virtualization, or deliberate code-splitting; standard build scripts exist but optimizations are not documented in code.
Accessibility & Semantics
3/10
Usable for everyone
Basic accessibility practices are present (labels, focus styling via Tailwind focus:ring), but custom widgets lack ARIA and there is no evidence of automated a11y testing or deeper focus management for keyboard users.
State Management & Data Flow
3/10
Managing data in the app
Clear pragmatic state and data flow using React hooks, axios-based API calls, FormData/file uploads, localStorage and basic loading/error states; however there is no evidence of request cancellation, optimistic updates with rollback, or state machines for complex flows.
Evidence
JukNavozn1k/Glebogram/frontend/src/pages/Auth/Paraphrase.js: localStorage usage, selectedWords state, API calls to /auth/login-paraphrase
JukNavozn1k/Glebogram/frontend/src/pages/Chats/Create.js: FormData construction, members Set usage and api.post('/chats/')
JukNavozn1k/Glebogram/frontend/src/pages/WebRTC.js: multi-step RTCPeerConnection lifecycle management in component state and refs
UX & Visual Polish
4/10
Look and feel quality
UX-focused touches are present - toast notifications, confirmation dialogs, file preview, spinner for loading and clear feedback flows - showing attention to perceived UX; more advanced patterns like undo stacks or progressive loading are not present.
Evidence
JukNavozn1k/Glebogram/frontend/src/pages/Chats/Create.js: react-hot-toast success/error flows and react-simple-dialogs confirmation
JukNavozn1k/Glebogram/frontend/src/components/Spinner.js: usage across pages to indicate loading states
JukNavozn1k/Glebogram/frontend/src/pages/Auth/Paraphrase.js: tabbed setup/login flow with immediate UI feedback
Expertise
Modern Web Frameworks• Middle
PWA & Web APIs• Middle
Frontend Architecture & Build Tools• Middle
Industries
Internet Services• Middle
Technologies
Node JS• Middle
Tailwind CSS
Next.js
Socket.IO
React.js
Axios
ESLint
React Hook Form
React Router
Turborepo
Recommendations
- Develop real-time communication features and client-side integrations (chat, WebRTC signaling, media flows), owning the end-to-end UX and reliability.
- Implement and extend frontend monorepo infrastructure - maintain ESLint/TypeScript configs, workspaces and CI build pipelines for multi-package apps.
- Lead feature work on SPA pages and form-heavy experiences (file uploads, member management, auth flows) where pragmatic API/form handling and UX polish are required.
- Improve robustness by introducing request cancellation/abort logic, automated a11y checks, and unit/integration tests around critical flows (auth, WebRTC, file upload).