Nikita Vasiliev

AI/ML • Senior
Python
C++
Java
Experimentation & Evaluation: 4/10
MLOps & Deployment: 4/10
Research Depth & Innovation: 4/10
Active 10 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles

Overview

A senior-level LLM-engineering practitioner focused on building defense-oriented tooling and microservices around LLM security and API analysis. The strongest proven skill is designing and implementing layered LLM defense and testing infrastructure, evidenced by the defense pipeline (L1-L9) and multi-layer attack/emulation code (defense layers in src/llm_security/features/defense and the MultiLayerAttackExecutor). There is limited evidence of model training, GPU/efficiency engineering or large-scale ML data pipelines in public code.

Technical skills

Python• Senior • 3y+
C++• Middle • 3y+
Java• Middle
Python
FastAPI
SQLAlchemy
Alembic
Pydantic
HTTPX
Uvicorn
Asyncio
Requests
PyQt
C++
OpenGL
STL
Java
Spring Boot
Databases
SQLite
DevOps
Rest API
Senior AI/ML Engineer Confidence: Low LLM Engineer
A senior-level LLM-engineering practitioner focused on building defense-oriented tooling and microservices around LLM security and API analysis. The strongest proven skill is designing and implementing layered LLM defense and testing infrastructure, evidenced by the defense pipeline (L1-L9) and multi-layer attack/emulation code (defense layers in src/llm_security/features/defense and the MultiLayerAttackExecutor). There is limited evidence of model training, GPU/efficiency engineering or large-scale ML data pipelines in public code.
Model Architecture & Training
2/10
How well models are designed and trained
Model-related work is limited to client/adapters and integration; no custom training loops or novel architectures are present.
Evidence
LLMSecurity/src/llm_security/features/models/infrastructure/openrouter.py: OpenRouterModelClient generate() adapter
LLMSecurity/src/llm_security/features/models/infrastructure/dummy.py: DummyModelClient adapter
LLMSecurity/src/llm_security/features/models/domain/interfaces.py: ModelClient interface
Data Pipeline & Feature Engineering
2/10
How data is prepared for models
Some parsing and config loading code exists (OpenAPI parsing, config loaders) but no large-scale ML data pipelines or feature engineering.
Evidence
api-analysis-service/src/services/openapi_parser.py: parse_specification, _parse_paths, _parse_parameters
LLMSecurity/src/llm_security/core/config/loader.py: ConfigLoader load_profiles/load_tests implementations
Experimentation & Evaluation
4/10
How results are measured and tested
Good test coverage and evaluation components for the LLM security domain (unit and integration tests, metrics/evaluation services) supporting reproducible checks and reporting.
Evidence
LLMSecurity/tests/test_core_config.py: extensive unit tests for ConfigLoader
LLMSecurity/src/llm_security/features/analysis/application/metrics_calculator.py: MetricsCalculator for analysis metrics
LLMSecurity/tests/test_testing.py: evaluator and runner tests for testing pipelines
MLOps & Deployment
4/10
How models are shipped to production
Microservice packaging, health checks, and orchestration utilities are present; evidence of deployment-minded config, health endpoints and service management.
Evidence
shared/common-utilities/src/security_orchestrator_common/health.py: HealthChecker, multiple HealthCheck implementations
process-management/pyproject.toml: packaging, mypy, pytest and CI-oriented configuration
start_services.py: ServiceManager orchestration utilities
Computational Efficiency
3/10
How efficiently computing resources are used
Asynchronous and concurrency patterns are used (asyncio, background tasks, batch processing and multi-layer executors), but there is no GPU/quantization or heavy performance engineering for ML.
Evidence
LLMSecurity/src/llm_security/features/attacks/application/attack_executor.py: uses asyncio and concurrent attack execution
LLMSecurity/src/llm_security/features/attacks/infrastructure/multi_layer_attack_executor.py: async multi-layer execution
api-analysis-service/test_ai_integration.py: async integration test orchestration
Research Depth & Innovation
4/10
Depth of research and new ideas
Thoughtful domain-specific design for LLM security (multi-layer defense pipeline, policy engine, suffix entropy detector) showing innovation in engineering defenses though not formal research reproduction.
Evidence
LLMSecurity/src/llm_security/features/defense/infrastructure/layers/l4_policy_engine.py: policy engine layer implementation
LLMSecurity/src/llm_security/features/defense/infrastructure/layers/l6_suffix_detector.py: adversarial suffix detector with entropy calculation
LLMSecurity/src/llm_security/features/defense/infrastructure/factory.py: multi-layer pipeline builder (L1-L9)
Expertise
AI Agents & Agentic Workflows• Senior
LLM• Senior
Industries
Cybersecurity• Senior
Energy & Utilities• Middle
Technologies
Python• Senior • 3y+
FastAPI
SQLite
Asyncio
HTTPX
Requests
PyQt
Recommendations
  • Lead development of LLM-hardening systems: design and implement defense pipelines, adapters to model clients, and attack-emulation testing harnesses.
  • Build API-security and observability features for ML services: health checks, monitoring, and secure OpenAPI analysis tooling (OpenAPIParser + SecurityAnalyzer).
  • Integrate the defense pipeline into CI and automated evaluation - expand reproducible experiment tracking and benchmarking (W&B/MLflow) for security tests.
  • Work on hybrid engineering tasks combining microservices orchestration and async execution (batching, rate-limiting, robust retries) for production LLM services.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
security-orchestrator-microservices LLMSecurity energy_twin_proto
Middle Backend Developer Confidence: Medium API Engineer
A backend API engineer at a solid middle level who builds orchestration layers and async Java services. The strongest proven skill is API orchestration and async mapping workflows, demonstrated by ApiTestingOrchestrator.java coordinating OpenAPI/BPMN/LLM components and CrossReferenceMapper.java using CompletableFuture/@Async and executor-based parallel mapping. The code lacks deep DB schema evolution, explicit auth/token management, and advanced resilience patterns (retries with backoff, circuit breakers, metrics), which are not evidenced in the human-authored files analyzed.
API Design
4/10
How well APIs are designed
API surface is reasonably designed with controllers, consistent ApiResponse usage and execution status endpoints, but lacks explicit versioning, idempotency keys, or advanced pagination contracts.
Evidence
nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/controller/testdata/DependencyController.java: DependencyController.getResourceDependencies / getDataFlowChains (validation + ApiResponse pattern) nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/api/ApiTestingOrchestrator.java: ApiTestingOrchestrator.getExecutionStatus (status / result contract)
Data Layer & Database
2/10
Working with databases
Data layer use is minimal in the analyzed human-authored files - primarily in-memory caches and DTO-style result objects; no schema evolution, migrations, or transactional DB interactions shown in these files.
Evidence
nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/controller/testdata/DependencyController.java: dependencyCache / chainCache in-memory caching nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/api/ApiTestingOrchestrator.java: executionContexts (ConcurrentHashMap) used as ephemeral store
Scalability & Performance
4/10
Handling load and speed
Concurrency and async execution are explicitly used (CompletableFuture, @Async, Executor, ConcurrentHashMap) and there are basic throttling/timeouts constants; however there is no evidence of advanced queueing, backpressure, measured performance tuning or cache invalidation strategies beyond simple TTL constants.
Evidence
nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/integration/CrossReferenceMapper.java: createCrossReferenceMapping uses @Async, CompletableFuture, custom Executor, MAX_CONCURRENT_MAPPINGS and CACHE_TTL_HOURS nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/api/ApiTestingOrchestrator.java: analyzeOpenApiSpec / executeEndToEndTesting use CompletableFuture.supplyAsync and ConcurrentHashMap for state
System Architecture
3/10
Overall system structure
There is a clear orchestration layer that composes multiple subservices (OpenAPI analysis, BPMN, test generators, LLM integration), showing modular boundaries; trade-offs and inter-service contracts (reliability, retries, async boundaries) are present but not deeply documented or enforced in code shown.
Evidence
nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/api/ApiTestingOrchestrator.java: orchestrates OpenApiAnalysisService, BpmnTestingIntegrationService, OwaspTestGenerator, TestDataGenerator nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/integration/CrossReferenceMapper.java: composes mapping tasks (ENDPOINT_TASK, DATA_FLOW, BUSINESS_SCENARIO, UNIFIED_CONTEXT)
Security & Auth
2/10
Protecting data and access
Surface-level input validation and error handling exist, but there is little evidence in the inspected human-authored files of authentication/authorization design, token lifecycle, secrets handling, or defensive measures against SQLi/SSRF at the boundaries.
Evidence
nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/controller/testdata/DependencyController.java: basic validation of path params and error ApiResponse usage nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/api/ApiTestingOrchestrator.java: exception handling that updates ExecutionContext and logs errors
Reliability & Observability
3/10
Stability and monitoring
Logging and runtime state tracking (ExecutionContext) are present and exceptions are caught and recorded; standard reliability/observability features (structured correlation ids, metrics export, retries with backoff, circuit breakers) are not evident in the analyzed human-authored files.
Evidence
nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/api/ApiTestingOrchestrator.java: extensive logging, ExecutionContext status/progress updates on success and exceptions nvmediagithub/SecutityOrchestrator/Backend/app/src/main/java-disabled/services/integration/CrossReferenceMapper.java: activeMappings cache and logging around mapping lifecycle
Expertise
Java• Middle
Microservices & API Architecture• Middle
Backend AI & LLM• Middle
Industries
Cybersecurity• Middle
Artificial Intelligence• Middle
Technologies
Java• Middle
Rest API
Spring Boot
SQLAlchemy
Pydantic
Uvicorn
Alembic
Recommendations
  • Lead development of API orchestration and integration services that coordinate OpenAPI, BPMN and LLM components using CompletableFuture and executor-backed async patterns.
  • Implement and harden LLM integration layers and mapping workflows (cross-reference mapping, caching, timeouts) where existing code shows clear focus and ownership.
  • Harden security and auth boundaries - add token lifecycle handling, input sanitization, and dependency secrets management for services that currently only log/validate inputs.
  • Improve reliability and observability by adding structured correlation IDs, Prometheus metrics, retries with backoff + jitter, and circuit breakers around external LLM and parser calls.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
SecutityOrchestrator security-orchestrator-microservices LLMSecurity
Middle Game Developer Confidence: Medium Engine & Graphics Engineer
A graphics-focused C++ developer at a mid (early-middle) level who implements rendering systems and scene loading. The strongest proven skill is low-level rendering and GPU workflow, evidenced by RenderManager.cpp (batching/sorting, shader uniform management, VAO/VBO usage and an instancing path). The public code lacks editor tooling, automated asset pipelines, profiling data, and network/deterministic simulation systems.
Gameplay Systems & Mechanics
1/10
How game logic works
Minimal gameplay systems - a basic main loop and scene loading but no decoupled game state machines or complex mechanics.
Evidence
nvmediagithub/Frustum_Culling/main.cpp:simulation() - simple input-driven camera movement and glutPostRedisplay nvmediagithub/Frustum_Culling/Scene.cpp:loadFromJson() - JSON-driven instantiation of graphic objects
Graphics & Rendering
5/10
Drawing game visuals
Clear, practical rendering work - custom RenderManager, shader uniform management, VAO/VBO use and an instancing hook, showing solid graphics programming practice.
Evidence
nvmediagithub/Frustum_Culling/RenderManager.cpp:drawAllObjects() - sorting for state-batching, shader uniform updates and mesh->drawMany(count) nvmediagithub/Frustum_Culling/RenderManager.cpp:drawViewFrustum() - VAO/VBO creation (glGenVertexArrays/glGenBuffers) and glDrawArrays for frustum visualization
Physics & Math
3/10
Game physics and math
Correct use of linear algebra for camera and frustum math, but no custom integrators, spatial partitioning or deterministic simulation.
Evidence
nvmediagithub/Frustum_Culling/RenderManager.cpp:drawViewFrustum() - inverse(projection*view) to compute world-space frustum corners nvmediagithub/Frustum_Culling/main.cpp:reshape() - camera.setProjectionMatrix(...) usage
Engine Proficiency
3/10
Skill with the game engine
Practical engine proficiency - custom managers and resource loading integrated with OpenGL/GLEW/FreeGLUT, but no editor tooling or advanced engine pipeline shown.
Evidence
nvmediagithub/Frustum_Culling/RenderManager.cpp - custom RenderManager with shader and resource handling nvmediagithub/Frustum_Culling/main.cpp - initialization sequence calling glewInit(), glutInit*, ilInit() and RenderManager::instance().init()
Performance & Frame Budget
4/10
Keeping the game smooth
Attention to frame-budget details - state sorting, cached texture/material bindings and an instancing pathway are present, but no profiler numbers or zero-alloc hot-paths documented.
Evidence
nvmediagithub/Frustum_Culling/RenderManager.cpp:drawAllObjects() - sort(...) to minimize state changes before rendering nvmediagithub/Frustum_Culling/RenderManager.cpp:setTexture() - previouseTextureID early-out to avoid redundant binds
Content Pipeline & Tooling
2/10
Tools for game content
Basic content pipeline work - JSON scene import using rapidjson, but no import automation, asset validation or CI pipeline artifacts.
Evidence
nvmediagithub/Frustum_Culling/Scene.cpp:init() and loadFromJson() - rapidjson Document parsing and JSON-driven scene construction
Expertise
Game Development Tools & Pipeline• Middle
Industries
Gaming• Middle
Technologies
C++• Middle • 3y+
OpenGL
STL
Recommendations
  • Develop low-level rendering features and optimizations - frustum culling, batching/instancing improvements and shader-driven material systems.
  • Implement and benchmark zero-alloc hot paths with profiler captures to validate frame-budget claims (measure before/after and store reports).
  • Extend the resource pipeline - asset importers/validators and a scene serialization/versioning system for safer content iteration.
  • Build small editor tools or inspector panels to expose material/shader parameters and scene placement to designers.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Frustum_Culling 2d_to_3d