Omar Elsaid
Deployed Engineer
6+ years exp
5+ projects
Bash
JavaScript
Node JS
PHP
Java
Python
SQL
TypeScript
API Design: 7/10
Security & Auth: 7/10
Reliability & Observability: 7/10
Active 2 days ago
+49 (152) 10526441 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Senior backend/platform engineer specializing in resilient Cloudflare Worker and container-based agent runtimes and integrations. The strongest proven skill is designing production-safe orchestration and recovery for long-running agent turns, evidenced by the sandbox clone/unshallow/exec logic and the accept-then-run dispatch + shutdown/heartbeat handling in nova-slack-agents/agent-runtime/src/index.ts and agent-runtime/container/src/server.ts. There is little or no public evidence of automated test suites, contract testing, property-based tests, or performance/load testing in the human-authored code.
Technical skills
Bash
JavaScript
Node JS• Senior
PHP
Java• 6y+ • 5+ projects
Python• Middle
SQL• Senior
TypeScript• Senior
PHP
Laravel
Python
Pydantic
FastAPI
Databases
SQLite
Databases
FAISS
PostgreSQL
AI/ML
Claude
Claude Code
Gemini
LangChain
LangGraph
Prompt Engineering
Reranking
OpenAI SDK
Anthropic SDK
Embeddings
LLM
RAG
Scikit-learn
AI Agents
DevOps
Docker
GitHub Actions
Rest API
Vector
Containers
CI/CD
Git
Cloudflare
GitLab CI
QA
Pytest
Sentry
Frontend
Next.js
React.js
Zod
Vue.js
Design
Webflow
Cybersecurity
GDPR
Timeline
German International University
Master's Degree •
Multi-agent system - Ai and Security
Independent Engineer
•
Middle
Direct clients
•
Full-Time
Owned the full lifecycle for client qualification and production launch, mapping the real workflow with operations teams and designing around adoption resistance. Built webhook ingest, model scoring, third-party enrichment, conditional routing, a human approval gate for outbound contact, and GDPR-compliant handling with idempotency and retry logic. Developed a RAG retrieval service using FastAPI with dense FAISS search plus BM25 and reranking, improving average lookup time from ~15 minutes to under 10 seconds.
FastAPI
Python
FAISS
RAG
GDPR
Software Engineer
•
Middle
Right Group
•
Full-Time
Led requirement discovery with client teams, produced system designs and API contracts, and communicated technical trade-offs to non-technical stakeholders. Built LLM-based backend components for structured extraction from unstructured documents with output validation, automating manual processing and reducing processing time by about 30%. Delivered features to client deadlines using agile sprints and Git-based code review.
Python
LLM
Git
Founding AI Engineer
•
Middle
Zeeg GmbH
•
Full-Time
Built and shipped an agentic AI platform end to end, including architecture decisions reviewed by both technical and non-technical stakeholders. Implemented an LLM routing layer that delegates to specialist agents across scoped tools, with human approval required before any data write. Designed data access safeguards such as credential redaction on reads and SQL guardrails with fail-closed permissions, and delivered reliability through CI-based end-to-end automation.
TypeScript
Python
PostgreSQL
Cloudflare
SQL
LLM
AI Agents
Laravel
Vue.js
Slack
GitLab CI
German University in Cairo
Bachelor's Degree •
Computer Science Engineering
Senior Backend Developer
Confidence: Medium API Engineer
Backend API engineer operating at a senior level, focused on resilient serverless container orchestration and Slack-integrated AI agent workflows. The strongest proven skill is designing robust Worker-to-container handoffs, idempotency and security controls as implemented in agent-runtime/src/index.ts and container/src/server.ts. There is little public evidence of formal DB migration histories, extensive load-testing artifacts, or a comprehensive test suite in the analyzed human-authored files.
API Design
7/10
How well APIs are designed
Strong API design for internal and external routes with consistent error handling, idempotency endpoints, and an accept-then-run handoff pattern that separates job acceptance from long-running work.
Evidence
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts: accept-then-run dispatchTurn and /slack-event handler with containerFetchWithRetry
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts: requireInternalAuth and internal routes (/help-center/search, /idempotency/*, /session-transcript/*) implementing auth and clear error responses
oommaarrr/nova-slack-agents/agent-runtime/container/src/server.ts: POST /slack-event and /slack-interaction handlers, clearly defined resume/approval flow
Data Layer & Database
6/10
Working with databases
Deliberate data-layer guards and redaction, schema/introspection caching, and limits for row reads; guarded Metabase access and a SQL guard to prevent sensitive-table reads and overly-broad queries.
Evidence
oommaarrr/nova-slack-agents/agent-runtime/container/src/workflows/metabase.ts: runGuarded, assertAggregateQuery/assertSingleSelectStatement, enforceRowLimit, schema caching
oommaarrr/nova-slack-agents/agent-runtime/container/src/workflows/sql-guard.ts: guard logic referenced across Metabase calls
oommaarrr/nova-slack-agents/agent-runtime/container/src/workflows/metabase.ts: toRedactedRows and redactRows usage to prevent leaking secrets
Scalability & Performance
6/10
Handling load and speed
Thoughtful scalability and cold-start handling: per-thread container instances, retries on container cold starts, serialized access to shared sandboxes, and caching to reduce repeated heavy operations.
Evidence
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts: containerFetchWithRetry and CONTAINER_FETCH_ATTEMPTS for cold-start resilience
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts: Sandbox-sharing decisions and SANDBOX_* timeouts (comments + logic) to control clone/unshallow costs
oommaarrr/nova-slack-agents/agent-runtime/container/src/server.ts: turnQueues and serializeByThread to avoid concurrent turn corruption
System Architecture
6/10
Overall system structure
Clear separation of components (Worker vs container), durable session storage, handoff/approval model and explicit decisions about secrets and bindings; pragmatic service decomposition for reasoned trade-offs.
Evidence
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts: Worker <-> container design, SESSION_STORE and AGENT_RUNTIME_CONTAINER binding choices
oommaarrr/nova-slack-agents/agent-runtime/container/src/server.ts: driveHandoffs and finishTurn implementing handoff mesh and approval flow
oommaarrr/nova-slack-agents/agent-runtime/container/src/server.ts: comments and health endpoint describing build marker and runtime visibility
Security & Auth
7/10
Protecting data and access
Concrete security-minded code: timing-safe comparisons, token redaction, strict validators for keys, deny-lists for PII/credentials, and guarded internal routes requiring a secret header.
Evidence
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts: requireInternalAuth and timingSafeEqual; redactToken used before logging
oommaarrr/nova-slack-agents/agent-runtime/container/src/server.ts: isValidIdempotencyKey and checks enforcing key shapes on /idempotency/* and /session-transcript/*
oommaarrr/nova-slack-agents/agent-runtime/container/src/workflows/sentry.ts: DENY_KEY_PATTERN and partitionPayload to withhold credential-like keys and mask personal data
Reliability & Observability
7/10
Stability and monitoring
Robust observability and reliability patterns: structured audit and error relay endpoints, retries with reasoned bounds, shutdown/termination handling that notifies in-flight turns, and timeouts to avoid OOMs and hangs.
Evidence
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts: dispatchTurn error paths, postSlackFailure, and CONTAINER_FETCH_ATTEMPTS retry logic
oommaarrr/nova-slack-agents/agent-runtime/container/src/server.ts: handleShutdown notifying active turns and activeTurns tracking, startKeepalive usage
oommaarrr/nova-slack-agents/agent-runtime/src/index.ts and container/src/server.ts: /turn-audit, /slack-error and /timing-relay endpoints for operational telemetry
Verified artifacts
Expertise
Microservices & API Architecture• Senior
Databases & Vector Storage• Middle
Messaging & Real-time• Senior
Industries
Financial Services• Middle
Sales & Marketing• Middle
Technologies
Databases
PHP
Node JS• Senior
Rest API
Laravel
SQLite
Vector
Recommendations
- Build Slack- or chat-integrated agent runtimes and approval-gated write flows (Worker + container orchestration, idempotency, durable state).
- Implement secure data-access tooling and RAG pipelines that combine guarded SQL access with vector retrieval and redaction (Metabase guarded queries + Vectorize ingestion).
- Design and harden operational runbooks and observability for serverless containerized AI systems (health endpoints, audit lines, graceful shutdown notifications).
- Develop internal orchestration for multi-agent handoffs and long-running tool chains with deadline budgeting and serialized sandbox access.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior QA Engineer
Confidence: High Generalist
Senior backend/platform engineer specializing in resilient Cloudflare Worker and container-based agent runtimes and integrations. The strongest proven skill is designing production-safe orchestration and recovery for long-running agent turns, evidenced by the sandbox clone/unshallow/exec logic and the accept-then-run dispatch + shutdown/heartbeat handling in nova-slack-agents/agent-runtime/src/index.ts and agent-runtime/container/src/server.ts. There is little or no public evidence of automated test suites, contract testing, property-based tests, or performance/load testing in the human-authored code.
Test Automation Frameworks
Building automated tests
Not evidenced in public code
Test Coverage & Strategy
What and how to test
Not evidenced in public code
API & Integration Testing
Testing how parts work together
Not evidenced in public code
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
4/10
Finding and describing bugs
Strong evidence of incident analysis and postmortem-driven fixes captured directly in code comments and operational handlers; many handlers and comments document live failures, root-cause reasoning and design changes made to prevent recurrence.
Evidence
nova-slack-agents/agent-runtime/src/index.ts: detailed sandbox, clone/unshallow retry, cold-start and dispatchTurn analysis and fixes
nova-slack-agents/agent-runtime/container/src/server.ts: extensive shutdown, serialization, handoff and acceptance-then-run reasoning with historical incident notes
nova-slack-agents/agent-runtime/container/src/workflows/sentry.ts: triage logic, retry ladders and documented real-world incidents with corrective design decisions
CI Test Integration
2/10
Running tests automatically
Basic project scripts and typecheck/deploy commands exist (npm workspaces, wrangler scripts and typecheck), but no CI workflows, test-run matrix, per-test retry policies, flaky quarantine mechanics, or artifact-history/trend integrations were found.
Evidence
nova-slack-agents/package.json: workspace scripts for dev/typecheck/deploy
nova-slack-agents/agent-runtime/container/package.json: dev/typecheck/start scripts and dependencies
Industries
Software• Middle
Technologies
CI/CD
Containers
TypeScript• Senior
Cloudflare
Pytest
Sentry
Recommendations
- Implement a focused API/contract test suite (contract tests + schema validation) for the Metabase, Sentry and external-API integrations to prevent regressions in edge/error paths.
- Add automated end-to-end and negative-path tests for the Worker <-> container handoff (mock container endpoint, idempotency and approval flows) and integrate them into CI with per-test artifact capture.
- Build a small performance benchmark (k6 or k6-like) for cold-start/cold-container scenarios and track percentiles before/after any sandbox or clone changes.
- Extract and document operational runbooks from the many inline postmortem notes and codify key checks as health probes and alert rules (e.g., container image/instance drift, long-running turn detection).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer
Confidence: High LLM Engineer
A practical LLM/RAG engineer (middle level) who builds modular retrieval and API service layers for grounded question answering with pragmatic engineering. The strongest proven skill is building retrieval and orchestration pipelines as seen in the ingestion, FAISS dense retriever and FastAPI startup wiring (ingest/loader.py, retrieval/dense.py, api/main.py). There is limited evidence of custom model training, experiment tracking, deployment manifests or advanced optimization work in public code.
Model Architecture & Training
2/10
How well models are designed and trained
Uses pretrained embedding and reranker models but contains no custom model architectures, training loops, or optimizer/scheduler choices.
Evidence
rag-knowledge-assistant/ingest/embedder.py: Embedder.embed and Embedder.embed_query usage of sentence-transformers
rag-knowledge-assistant/retrieval/reranker.py: Reranker class using CrossEncoder for reranking
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear document ingestion and chunking pipeline with sensible splitter choices and file loader support for PDFs and text.
Evidence
rag-knowledge-assistant/ingest/loader.py: load_documents handles PyPDFLoader and TextLoader
rag-knowledge-assistant/ingest/loader.py: chunk_documents using RecursiveCharacterTextSplitter with chunk_size and chunk_overlap
Experimentation & Evaluation
2/10
How results are measured and tested
Has basic automated tests for retrieval and service import but no experiment tracking, baselines, ablation scripts or reproducible experiment harness.
Evidence
rag-knowledge-assistant/tests/test_pipeline.py: unit tests for SparseRetriever and reciprocal_rank_fusion
rag-knowledge-assistant/tests/test_pipeline.py: health endpoint import test using fastapi.testclient
MLOps & Deployment
3/10
How models are shipped to production
Contains a production-oriented FastAPI service layer and startup initialization of indexes but lacks deployment manifests, CI workflows or monitoring instrumentation in code.
Evidence
rag-knowledge-assistant/api/main.py: FastAPI app with startup event that builds dense and sparse indexes
rag-knowledge-assistant/api/main.py: Pydantic request/response models and HTTP error handling
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to retrieval efficiency via FAISS index usage and float32 embeddings but no explicit batching, GPU/FP optimization, quantization or profiling.
Evidence
rag-knowledge-assistant/retrieval/dense.py: use of faiss.IndexFlatIP and conversion to float32
rag-knowledge-assistant/ingest/embedder.py: embedding of text lists into numpy arrays
Research Depth & Innovation
2/10
Depth of research and new ideas
Shows applied knowledge of retrieval algorithms like Reciprocal Rank Fusion but implements standard techniques rather than novel research.
Evidence
rag-knowledge-assistant/retrieval/hybrid.py: implementation of Reciprocal Rank Fusion
rag-knowledge-assistant/retrieval/reranker.py: cross-encoder reranking integration
Expertise
RAG• Middle
LLM• Middle
Industries
Professional Services• Middle
Technologies
Python• Middle
SQL• Senior
PostgreSQL
LangGraph
LangChain
Claude
FAISS
Claude Code
GitHub Actions
FastAPI
Embeddings
Scikit-learn
Prompt Engineering
AI Agents
Anthropic SDK
GitLab CI
OpenAI SDK
Git
Docker
Gemini
Pydantic
Reranking
Recommendations
- Develop production deployment artifacts - e.g., Dockerfiles, Kubernetes manifests or GitHub Actions workflows to make the service reproducibly deployable.
- Add experiment tracking and evaluation scripts (W&B or MLflow) and end-to-end evaluation harnesses to measure generation quality and retrieval effectiveness.
- Expand test coverage and add integration tests that exercise end-to-end retrieval to generation flows with synthetic fixtures and CI gates.
- Work on efficiency improvements like batched embedding, optional GPU/quantized inference and profiling to reduce latency and memory usage
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: