Youssef Ramadan
Full Stack Developer
6+ years exp
4+ projects
Node JS
JavaScript
Python
MLOps & Deployment: 4/10
Active 1 day ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Experienced LLM systems engineer (senior) focused on building reliable, multi-agent orchestration and agent-security tooling. The strongest proven skill is architecting resilient agent orchestration and real-time pipelines, exemplified by the Band-based event_runtime, Band client, SSE stream handlers, and the PagerZero multi-agent pipeline tests. Public code does not show custom model training, low-level model optimization (quantization/GPU kernels), or experiment tracking infrastructure.
Technical skills
Node JS
JavaScript• Senior • 6y+ • 4 projects
Python• Senior • 5y+ • 4 projects
Python
HTTPX
FastAPI• 5y+ • 4 projects
Pydantic• 5y+ • 4 projects
SQLAlchemy• 5y+ • 4 projects
Uvicorn• 5y+ • 4 projects
Asyncio• 5y+ • 4 projects
Databases
MySQL
Pinecone
Qdrant
Supabase
PostgreSQL
PostGIS
AI/ML
Cohere SDK
Docling
Embeddings
Haystack
Hybrid Search
LangChain
LangGraph
LiteLLM
LLM
PaddleOCR
Prefect
Prompt Engineering
Qwen
RAG
Reranking
Semantic Search
Streamlit
PaddlePaddle
DevOps
Amazon EC2
ArgoCD
AWS
Azure
Docker
External Secrets
Git
GitHub Actions
GitOps
Kubernetes
OpenShift
Rest API
Terraform
WebSockets
Frontend
React.js
Next.js• 4y+ • 4 projects
Timeline
Ecole supérieure libre des sciences commerciales appliquées (ESLSCA)
Bachelor's Degree •
Computer Science
Full-Stack AI Engineer & DevOps
•
Middle
Atelic Core Studio
•
Full-Time
Owned the backend architecture for an AI studio product, building modular Python/FastAPI services for model orchestration, retrieval, document ingestion, guardrails, and evaluation. Delivered agentic RAG and deep-research workflows using typed Haystack pipelines with decomposition, conditional retrieval loops, evidence-gap checks, hybrid search, reranking, and citation grounding. Built document-intelligence pipelines using Docling plus PDF/OCR tooling and validated structured outputs with Pydantic schemas. Set up production infrastructure and delivery automation with Terraform, GitHub Actions, Docker, and GitOps-style deployment on Kubernetes.
Python
FastAPI
Haystack
LangChain
LangGraph
Qdrant
Docling
PaddleOCR
Pydantic
LiteLLM
Docker
Kubernetes
Terraform
AWS
Azure
GitHub Actions
ArgoCD
Git
Embeddings
Hybrid Search
Reranking
Senior AI/ML Engineer
Confidence: Low LLM Engineer
Experienced LLM systems engineer (senior) focused on building reliable, multi-agent orchestration and agent-security tooling. The strongest proven skill is architecting resilient agent orchestration and real-time pipelines, exemplified by the Band-based event_runtime, Band client, SSE stream handlers, and the PagerZero multi-agent pipeline tests. Public code does not show custom model training, low-level model optimization (quantization/GPU kernels), or experiment tracking infrastructure.
Model Architecture & Training
2/10
How well models are designed and trained
Mostly LLM orchestration and prompt engineering rather than custom model architecture or training. No custom training loops, schedulers, or novel loss/optimizer choices are present.
Evidence
PagerZero/backend/src/pagerzero/agents/prompts/deployment_tracker.py
PagerZero/backend/src/pagerzero/agents/prompts/log_analysis.py
PagerZero/backend/src/pagerzero/llm/client.py
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Deterministic data loaders and scenario generation for demos and deterministic pipelines are present; ingestion and parsing logic is solid but there is no large-scale ETL or advanced feature engineering shown.
Evidence
SafetySignal-Desk/safety_signal/data_loaders.py
SafetySignal-Desk/scripts/fetch_openfda.py
SafetySignal-Desk/safety_signal/case.py
Experimentation & Evaluation
3/10
How results are measured and tested
Meaningful unit and integration tests exist across projects and canned fixtures simulate LLM outputs; there is no evidence of experiment tracking (W&B/MLflow) or systematic ablation studies.
Evidence
PagerZero/backend/tests/test_api.py
AgentShield/tests/test_scanner.py
AgentShield/tests/test_shield.py
MLOps & Deployment
4/10
How models are shipped to production
Well-architected serving and orchestration: FastAPI apps, SSE streaming, WebSocket listeners, robust reconnect and REST fallbacks, and Streamlit UI. Deployment automation and production-grade MLOps (model lifecycle, drift monitoring) are not shown.
Evidence
SafetySignal-Desk/web/server.py
SafetySignal-Desk/safety_signal/band_client.py
PagerZero/backend/src/pagerzero/api/main.py
Computational Efficiency
2/10
How efficiently computing resources are used
Attention to responsiveness and async concurrency is evident (asyncio, SSE, reconnect/backoff), but there is little evidence of GPU/quantization work, batching/throughput profiling, or memory/GPU optimization.
Evidence
SafetySignal-Desk/safety_signal/event_runtime.py
AgentShield/demo_auto.py
Research Depth & Innovation
3/10
Depth of research and new ideas
Strong applied security research in the agent/security domain (threat signatures, OWASP mapping, red-team payloads). There is domain research depth in detection rules but not in new ML algorithms or paper-replicated model advances.
Evidence
AgentShield/backend/scanner/threat_db.py
AgentShield/backend/redteam/attacks.py
AgentShield/backend/scanner/skill_parser.py
Expertise
AI / LLM Engineering (Agents)• Senior
Cybersecurity & Threat Intelligence• Senior
Industries
Food & Beverages• Middle
Technologies
Python• Senior • 5y+ • 4 projects
MySQL
PostgreSQL
Supabase
LangGraph
Rest API
LangChain
Qwen
Terraform
Pinecone
Qdrant
SQLAlchemy• 5y+ • 4 projects
OpenShift
GitHub Actions
FastAPI• 5y+ • 4 projects
Prefect
WebSockets
Embeddings
Prompt Engineering
Cohere SDK
Docling
Haystack
LiteLLM
Azure
GitOps
ArgoCD
Git
PaddlePaddle
AWS
Docker
Kubernetes
LLM
RAG
Asyncio• 5y+ • 4 projects
Streamlit
Pydantic• 5y+ • 4 projects
HTTPX
Uvicorn• 5y+ • 4 projects
External Secrets
PaddleOCR
Amazon EC2
Reranking
Semantic Search
Hybrid Search
AI Agents• mentioned only
Claude• mentioned only
Claude Code• mentioned only
Gemini• mentioned only
Qwen• mentioned only
Recommendations
- Design and implement multi-model agent orchestration and production LLM pipelines (SSE/streaming, robust fallbacks, monitoring).
- Develop agent-security products (static scanner, red-team simulator, output shielding and vault proxy) and integrate them into CI/CD for enterprise deployments.
- Build incident-response automation systems that synthesize logs, metrics, and deploy data into grounded LLM-driven hypotheses and human-reviewable artifacts.
- Lead engineering work converting deterministic pipelines and mock fixtures into reproducible evaluation suites and lightweight experiment tracking for LLM behavior.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Low API Engineer
Senior backend engineer specializing in secure AI-agent tooling and real-time orchestration. The strongest proven skill is resilient agent orchestration and real-time WebSocket fallback logic, as implemented in safety_signal/event_runtime.py and safety_signal/band_client.py. There is limited public evidence of large multi-service production deployments, long migration histories, or formal load-testing and observability pipelines.
API Design
6/10
How well APIs are designed
Clear, pragmatic API layering with typed endpoints and graceful error handling; some idempotency and upsert patterns are present but no explicit API versioning or global contract/versioning strategy was found.
Evidence
SafetySignal-Desk/safety_signal/band_client.py: _BaseRest wrapper and BandAgentClient/BandHumanClient REST methods
AgentShield/backend/routers/scan.py: FastAPI router endpoints and pydantic request/response shapes
AgentShield/backend/vault/proxy.py: proxy_request building auth headers and controlled outbound calls
Data Layer & Database
5/10
Working with databases
Reasonable data-layer design using SQLAlchemy with DB session helpers and seed/demo scripts; transactional usage is visible but there is limited evidence of migration history or advanced tuning of SQL/isolation settings.
Evidence
AgentShield/backend/db/database.py: SQLAlchemy declarative models, init_db and sessionmaker
AgentShield/backend/seed_demo.py: init_db and sample seeding workflow
AgentShield/tests/test_vault.py: tests exercising DB-backed vault/audit flows
Scalability & Performance
6/10
Handling load and speed
Good asynchronous, concurrent design for real-time work (WebSocket + polling fallback) and fast output scanning; shows attention to latency constraints though no large-scale load testing artifacts are present.
Evidence
SafetySignal-Desk/safety_signal/event_runtime.py: _resilient_listen, _catchup_poll and heartbeat/reconnect logic for robust WebSocket handling
SafetySignal-Desk/safety_signal/band_client.py: listen_ws implementation with SSL/certifi and heartbeat; _BaseRest uses httpx.Client with timeouts
AgentShield/backend/shield/secret_detector.py: designed for real-time use (<100ms for small texts) and returns scan_duration_ms
System Architecture
6/10
Overall system structure
Deliberate modular architecture with multiple security layers (GATE/POSTURE/SHIELD/VAULT), clear module boundaries and focused responsibilities; service decomposition is sensible for the product scope.
Evidence
AgentShield/README.md and backend/*: explicit layered design (GATE, POSTURE, SHIELD, VAULT) and modular routers
AgentShield/backend/scanner/skill_parser.py: separate scanner/parser module for skill ecosystems
AgentShield/backend/redteam/attacks.py: distinct red-team module to exercise the system
Security & Auth
7/10
Protecting data and access
Strong security awareness and concrete protections: encrypted vault (AES-GCM), domain allow-listing for proxying, secret-detection with false-positive heuristics and masking; shows active threat-model thinking.
Evidence
AgentShield/backend/vault/store.py: AESGCM-based encrypt/decrypt of vault entries
AgentShield/backend/vault/policy.py: domain allow-listing and method checks for proxying credentials
AgentShield/backend/shield/secret_detector.py: API key patterns, false-positive filters, masking and entropy checks
Reliability & Observability
6/10
Stability and monitoring
Operational reliability patterns are present: reconnect and retry strategies, idempotent handlers, graceful fallbacks, and simple timing/metrics exposure; lacks full-fledged observability (prometheus/alerts) or documented SLOs in code.
Evidence
SafetySignal-Desk/safety_signal/event_runtime.py: kickoff guard, reconnect loops, catch-up polling for missed messages
SafetySignal-Desk/safety_signal/band_client.py: _BaseRest timeouts and exception handling around HTTP calls
AgentShield/backend/shield/secret_detector.py: returns scan_duration_ms and includes deduplication for findings
Expertise
Backend AI & LLM• Middle
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Python• Middle
Recommendations
- Lead development of agent-security platforms and vault+proxy integrations that prevent secret exfiltration (vault/store.py, vault/proxy.py).
- Build real-time, resilient orchestration systems and operator UIs for regulated workflows (event_runtime.py and Streamlit app).
- Implement RAG-backed diagnostic services and documented LLM integration hooks (LLMClient/classifier modules) with careful budget and fallback controls.
- Harden observability and SRE practices: add metrics, tracing, SLOs, and documented migration history for database schema evolution.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: High Generalist
Senior backend engineer specializing in AI-driven document-processing and banking automation pipelines. The strongest proven skill is designing concurrent, streaming agent pipelines and resilient file ingestion demonstrated by Meridian/backend/routes/analyze.py together with Meridian/backend/services/sse_manager.py. There is little public evidence of structured test automation, CI test integration, or formal performance/load testing artifacts in the human-authored code.
Test Automation Frameworks
1/10
Building automated tests
Minimal evidence of a test automation framework; codebase contains production async orchestration and streaming but no local test fixtures, factories, or parallelized test harness in the human-authored files.
Evidence
Meridian/backend/routes/analyze.py: asyncio.create_task(run_pipeline_task(...)) showing orchestration
Meridian/backend/services/sse_manager.py: SSEManager.publish/subscribe indicating streaming infrastructure
Test Coverage & Strategy
1/10
What and how to test
No structured test coverage or risk-based test strategy visible in the analyzed human-authored source; type schemas and typed interfaces suggest awareness of invariants but not explicit property or negative-path tests.
Evidence
Meridian/backend/models/schemas.py: Pydantic result models defining expected shapes
Meridian/frontend/src/lib/types.ts: typed AnalysisResults and ExaminationResults used to encode expected data shapes
API & Integration Testing
2/10
Testing how parts work together
API design and error handling are present; endpoints include defensiveness and clear failure responses but there is no evidence of contract-testing, schema-driven tests, or integration harnesses in the human-authored files.
Evidence
Meridian/backend/routes/analyze.py: POST /api/analyze with input validation and graceful task kickoff
Meridian/backend/routes/examine.py: input validation and HTTPException use for 400/404 scenarios
Performance & Load Testing
1/10
Testing speed under load
Some concurrency and streaming patterns indicate performance awareness, but no load/threshold/ramp testing artifacts or tooling are present.
Evidence
Meridian/backend/routes/analyze.py: concurrent agent tasks and use of async for pipeline streaming
Meridian/backend/services/sse_manager.py: asyncio-based SSE manager showing concurrency usage
Bug Reporting & Analysis
1/10
Finding and describing bugs
Basic runtime observability and exception logging exist, but there are no public bug reports, RCA docs, or flaky-test investigations in the human-authored files.
Evidence
Meridian/backend/routes/analyze.py: logger.exception usage in exception handler
Meridian/backend/routes/examine.py: logger.exception and explicit HTTP error handling
CI Test Integration
1/10
Running tests automatically
No CI/test-integration artifacts found in the human-authored bucket; server code contains good error handling but no per-test retry/quarantine or CI test matrix configuration in analyzed files.
Evidence
Meridian/backend/main.py: FastAPI app wiring and route registration (production entrypoints present)
Meridian/backend/routes/analyze.py: async task patterns but no CI or test-run integration hooks
Expertise
API Testing & Contract Validation• Middle
Industries
Financial Services• Middle
Recommendations
- Develop production orchestration and streaming backends that coordinate LLM agents and RAG retrieval in regulated domains (banking compliance, trade finance).
- Build robust document-ingestion and PDF/reporting pipelines with strict schema validation and audit trails for financial workflows.
- Lead API design and contract validation work (OpenAPI/Pydantic-driven contract tests and consumer-driven contract tooling).
- Implement a focused test-infra project: contract tests, deterministic end-to-end fixtures for the agent pipeline, and CI integration with artifact collection for flaky-run analysis.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: