Sarfaraz Khan

AI/ML • Senior • Management: 3-5 years (6-15 people) • Dubai, UAE • UTC+04:00 • Relocation • Work permits: United Arab Emirates • Available now

ML Engineer

Management: 3-5 years (6-15 people)

Python

SQL

Data Pipeline & Feature Engineering: 6/10

MLOps & Deployment: 6/10

Experimentation & Evaluation: 5/10

Active 2 days ago

Invite to interview

Download CVCV

Overview

Technical skills

Timeline

Roles

Overview

A senior-level backend engineer (approximate level Senior) focused on building robust database-backed real-time pipelines for operational systems. The most proven skill is designing and implementing idempotent, transactional event-to-lifecycle database processing as seen in src/visiontrack/event_processor.py and the repository modules. Public code lacks evidence of a production-grade auth lifecycle, service-level structured telemetry, and formal multi-service distributed contracts.

Phone

Technical skills

Languages

Python

SQL

Python

Flask

Asyncio

Boto3

Pydantic

FastAPI

AI/ML

NumPy

Pandas

LangChain

LangGraph

OpenCV

YOLO

Streamlit

RAG

MLFlow

NVIDIA NeMo

Ultralytics

Scikit-learn

Groq

LLM

Machine Learning

CrewAI

Transformers

PyTorch

Portkey

NLP

DVC

TensorFlow

Keras

Hugging Face

Jupyter Notebook

DevOps

Rest API

Docker

AWS

Azure

Kubernetes

Amazon EC2

GitHub

GitHub Actions

Grafana

Git

Linux

Prometheus

Databases

MySQL

Qdrant

Pinecone

Other

Power BI

AI Agents

CI/CD

Embeddings

Prompt Engineering

Fine-tuning

Multi-Agent Systems

Semantic Search

Computer Vision

Multimodal AI

LLM Evaluation

Interpretability

Tool Use

Red Teaming

Semantic Search

Hallucination

Timeline

AI/ML Project Associate • Middle

ALM IT Services Inc • Contractor

Apr 2026 to Sep 2026 5 Months Partially remote

Built an end-to-end warehouse vision pipeline using YOLO and OpenCV for pallet/box detection, tracking, and event verification. Implemented event-state logic for move/stack/removal and tuned sampling, resizing, and detection thresholds for faster video processing.

Python

YOLO

OpenCV

AI Analytics • Middle

CYBRIX Technologies Solution • Contractor

Jul 2026 to Sep 2026 2 Months Dubai In office

Delivered Python and SQL data workflows and built Power BI dashboards to turn operational data into reusable reporting. Automated recurring preparation and reporting steps by integrating structured data sources, APIs, and analytics outputs into a consistent process.

Python

SQL

Power BI

AI Automation Consultant • Middle

Aptech • Full-Time

Jul 2025 to Mar 2026 8 Months In office

Designed LLM-assisted automation workflows that combine prompts with API calls, structured data, and rule-based routing. Built reusable components for data extraction, response generation, and workflow handoffs to support repeatable business operations.

LLM

Prompt Engineering

Rest API

Python

AI/ML Intern - WBL Program • Junior

C-DAC • Internship

Oct 2025 to Feb 2026 4 Months Bengaluru In office

Prepared datasets and benchmarked classification models using cross-validation and standard evaluation metrics such as precision, recall, and F1-score. Used results to support evidence-based model selection for downstream tasks.

Machine Learning Intern • Junior

C-DAC • Internship

Jun 2025 to Sep 2025 3 Months Bengaluru In office

Developed supervised machine learning pipelines including preprocessing, training, hyperparameter tuning, and validation. Compared model variants to evaluate performance trade-offs and improve predictive results.

Data Science Intern • Junior

Varcons Technologies • Internship

Jan 2025 to May 2025 4 Months In office

Cleaned and analyzed structured data using Python and SQL, then translated findings into Power BI dashboards for stakeholder reporting. Contributed predictive modeling outputs as part of data-driven analysis and evaluation.

Python

SQL

Power BI

Senior AI/ML Engineer Confidence: Low LLM Engineer

LLM-focused engineer (senior level) who builds production RAG pipelines, guardrails and LLM gateway integrations. The strongest proven skill is designing and operating production LLM systems and evaluations, evidenced by the Portkey gateway notebooks and the evals pipeline (evals/metrics.py and notebooks/03_evals.ipynb). Public code shows excellent engineering for ingestion, retrieval and real-time vision dashboards but lacks custom model training loops, detailed GPU profiling, or formal experiment tracking artifacts.

Model Architecture & Training

2/10

How well models are designed and trained

Minimal evidence of custom model training or architecture work; most ML use is orchestration of hosted/models and judge LLMs rather than pretraining or custom training loops.

Evidence

notebooks/03_evals.ipynb: builds judge LLM pipelines and uses ragas metrics but does not implement custom training loops

evals/metrics.py: constructs LLM-based metrics (AsyncOpenAI judge) and embeds, no custom model or training code

Data Pipeline & Feature Engineering

6/10

How data is prepared for models

Strong, production-style data ingestion and retrieval pipeline work: file parsers, chunking, embedding, batching and Qdrant indexing are implemented and orchestrated with error handling and local persistence.

Evidence

app/ingestion/processor.py: parsing, chunking, local processed JSON save, embedding and Qdrant upsert

app/ingestion/chunking/splitter.py: chunk_text function used across ingestion flows

app/services/retrieval/qdrant_service.py: Qdrant integration and search hooks

Experimentation & Evaluation

5/10

How results are measured and tested

Dedicated evaluation and experiment artifacts including RAGAS metrics, judge pipelines, cooldowns and notebooks for reproducible experiments; decent reproducibility but no formal experiment tracking system observed.

Evidence

notebooks/03_evals.ipynb: end-to-end evaluation experiments using RAGAS and DeepEval

evals/pipeline.py and evals/metrics.py: live pipeline and metric orchestration for judge LLM scoring

evals/guardrails_eval.py: automated guardrails test harness hitting the live /query API

MLOps & Deployment

6/10

How models are shipped to production

Clear MLOps and deployment engineering: LLM gateway integration (Portkey), guardrails integration, FastAPI endpoints, Qdrant collection lifecycle, Streamlit UI and packaging for the vision app; tangible attention to observability and resilience.

Evidence

notebooks/02_llm_gateway.ipynb: Portkey gateway, retries, fallbacks, caching and LangChain drop-in

app/main.py and app/gateway/client.py: gateway and FastAPI integration (query endpoint, LLM client wiring)

visiontrack/dashboard/app.py: Streamlit dashboard with DB pooling and cached queries

Computational Efficiency

4/10

How efficiently computing resources are used

Practical efficiency work is visible (cooldowns for rate limits, batching and caching strategies, fallback routing) but there is little low-level GPU/memory profiling, quantization, or empirical before/after performance measurements.

Evidence

evals/metrics.py: COOLDOWN_STANDARD, CONTEXT_TRUNCATE and batch size comments to control throughput

notebooks/02_llm_gateway.ipynb: caching, load balancing and fallback configs for latency/cost control

app/services/retrieval/ranking_service.py: use of FlashRank re-ranker for performance-minded retrieval

Research Depth & Innovation

4/10

Depth of research and new ideas

Good practical innovation in system composition - LangGraph agents, NeMo Guardrails and gateway patterns - but this is engineering integration of existing research rather than new algorithmic research or novel model architectures.

Evidence

notebooks/01_guardrails.ipynb: layered guardrails experiments combining Colang + Python actions

app/guardrails/rails.py and evals/guardrails_eval.py: guardrails initialization and binary eval harness

ARCHITECTURE.md and notebooks: system-design thinking for agentic RAG

Expertise

AI Agents & Agentic Workflows• Senior

RAG• Senior

Industries

Artificial Intelligence• Senior

Transportation & Logistics• Senior

Technologies

SQL• since 2025

MySQL

LangGraph• since 2025

DVC• since 2025

LangChain• since 2025

Pinecone

OpenCV• since 2026

Qdrant

Groq

MLFlow• since 2025

YOLO• since 2026

GitHub Actions

Prometheus

Embeddings

Prompt Engineering• since 2025

Computer Vision• since 2026

AI Agents

NLP• since 2024

Portkey

Azure

CI/CD

Transformers

TensorFlow• since 2026

Keras

Git• since 2026

PyTorch

AWS

Docker• since 2025

Kubernetes

CrewAI

Grafana

LLM• since 2025

RAG• since 2025

Asyncio

Ultralytics

Amazon EC2

Semantic Search

Hugging Face

GitHub• since 2026

NVIDIA NeMo

Semantic Search

Multi-Agent Systems

Linux• since 2026

Machine Learning• since 2025

Vision• mentioned only

Recommendations

Develop production-grade RAG/agentic systems with guardrails and LLM gateway routing, fallbacks and observability.
Build real-time computer vision products for warehouses or logistics, including YOLO-based inference, QR tracking and Streamlit operational dashboards.
Implement robust ingestion and retrieval pipelines with chunking, embeddings and Qdrant indexing for enterprise knowledge bases.
Create evaluation suites and automated metric pipelines (RAGAS/DeepEval) to measure faithfulness, relevancy and tool-correctness for deployed agents.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

mohdsarfarazullakhan Production_Grade_Enterprise_RAG-AgenticAI- visiontrack-realtime-system

Senior Backend Developer Confidence: High Data Platform

API Design

4/10

How well APIs are designed

API contracts and idempotency for the event->lifecycle boundary are deliberate and well tested, but there is no public HTTP/REST API surface design or versioning strategy in the backend code.

Evidence

src/visiontrack/event_processor.py: lifecycle_already_exists and source_reference usage for idempotent lifecycle inserts

src/visiontrack/event_processor.py: lock_event / mark_processed / mark_error transaction flow that enforces an event processing contract

Data Layer & Database

7/10

Working with databases

Strong database layer: hand-authored SQL, careful transaction boundaries, FOR UPDATE locking, idempotency checks, pooling, and unit tests exercising schema and persistence logic.

Evidence

src/visiontrack/database/repository.py: complex persistence logic and careful use of transactions for order_lifecycle_events

src/visiontrack/database/cloud_repository.py: connection factory, schema validation and compatibility checks

src/visiontrack/dashboard/app.py: many hand-tuned SQL queries against information_schema and heavy read queries used to build dashboard data

Scalability & Performance

5/10

Handling load and speed

Practical scalability and performance work is present (DB pooling, caching, batch processing), but there are no load-test artifacts, distributed queue integration, or measured optimization bench marks.

Evidence

src/visiontrack/event_processor.py: persistent single DB connection reused, batch fetching (run_batch) and configurable batch_size/poll_ms

src/visiontrack/dashboard/app.py: _database_pool using mysql.connector pooling and @st.cache_data/@st.cache_resource for caching DB results

pyproject.toml and requirements.txt: explicit GPU-enabled inference packages (torch, ultralytics) indicating attention to inference performance

System Architecture

5/10

Overall system structure

Clear module boundaries and separation of concerns (perception, pipeline, event processing, database, dashboard) show deliberate architecture for a single deployable system, but there is no multi-service contract or distributed-system decomposition beyond the DB-backed pipeline.

Evidence

src/visiontrack/*: modular layout with perception/, pipeline/, database/, warehouse/, dashboard/ and CLI entry points

src/visiontrack/cli.py and src/visiontrack/main.py: CLI and entry separation for operational workflows

src/visiontrack/event_processor.py: explicit reconciliation loop separating real-time event processing and completed-run reconciliation

Security & Auth

4/10

Protecting data and access

Good defensive practices around DB parameters and environment-configured secrets are present, with parameterized SQL usage and some validation, but there is limited evidence of a full authn/authz model or secret rotation practices.

Evidence

src/visiontrack/event_processor.py: parameterized cursor.execute calls (resolve_code and many INSERT/UPDATE statements) limiting SQL injection risk

src/visiontrack/dashboard/app.py: get_env_config reads credentials from environment and uses connection pooling; tests reference SSL identity verification in cloud repository tests (tests/test_cloud_repository.py)

Reliability & Observability

6/10

Stability and monitoring

Strong reliability patterns: transaction commit/rollback, explicit idempotency checks, error-marking, graceful shutdown handlers, reconcilers and tests for transient failures. Observability is basic (prints/logging) rather than full structured telemetry, but error handling and retry semantics are solid.

Evidence

src/visiontrack/event_processor.py: start_transaction, connection.commit / rollback, mark_error, reset_errors and signal handlers for graceful shutdown

src/visiontrack/database/cloud_repository.py and tests/test_cloud_repository.py: connection factory with transient retry/backoff behavior and unit tests for retry semantics

Expertise

Python• Senior

Databases & Vector Storage• Senior

Backend AI & LLM• Middle

Messaging & Real-time• Senior

Industries

Transportation & Logistics• Senior

Technologies

Python• since 2025 • Senior

Rest API• since 2025

Flask• since 2024

FastAPI

Recommendations

Lead development of DB-backed real-time ETL and reconciliation components that require idempotency, transaction safety and schema-aware persistence.
Implement and extend video inference-to-business pipelines where careful SQL, reconciliation logic and CV-to-master-entity mapping are required.
Build dashboarding and operational tooling that surface CV-run metrics, pooling and cache strategies for live monitoring.
Harden observability by adding structured logging, correlation ids, and metrics/alerting integration around the event processor and DB operations.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

mohdsarfarazullakhan visiontrack-realtime-system AI_Script_Evaluation_System

Middle Data Scientist Confidence: Low Data Engineer

Enterprise-focused data engineer / MLOps practitioner building RAG and ingestion pipelines with evaluation tooling. The strongest proven skill is building end-to-end ingestion and vector-indexing pipelines, demonstrated by app/ingestion/processor.py which parses, chunks, embeds, saves metadata, and indexes into Qdrant. Public code shows solid engineering for pipelines and evaluations but limited formal statistical rigor, test automation, pinned environments, and business-metric instrumentation.

Statistical Rigor

3/10

Correct use of statistics

Statistical workflows rely on standard ML metrics and cross-validation but lack formal assumption checks, uncertainty quantification, multiple-comparison controls, or causal analysis.

Evidence

Finance_Proj_MLOps/notebook/exp-notebook.ipynb

Finance_Proj_MLOps/src/components/model_evaluation.py

Data Wrangling & Cleaning

6/10

Preparing and cleaning data

Robust ingestion and cleaning code is present; document parsing, chunking, embedding and vector indexing are implemented with Qdrant integration and reusable processors.

Evidence

app/ingestion/processor.py

Finance_Proj_MLOps/src/components/data_transformation.py

Exploratory Analysis & Visualization

4/10

Exploring and visualizing data

Notebooks include many EDA plots and readable explanations, but visual analysis is mainly descriptive and lacks deeper hypothesis-driven interpretation and follow-through.

Evidence

Finance_Proj_MLOps/notebook/exp-notebook.ipynb

Production_Grade_Enterprise_RAG-AgenticAI-/notebooks/03_evals.ipynb

Predictive Modeling

5/10

Building models that predict

Predictive modeling and training pipelines are implemented (RandomForest, hyperparameter search, training/evaluation/persistence) with an MLOps-oriented trainer/evaluator flow, but limited advanced model validation, calibration, or robustness checks are present.

Evidence

Finance_Proj_MLOps/src/components/model_trainer.py

Finance_Proj_MLOps/notebook/exp-notebook.ipynb

Business Insight & Impact

2/10

Turning analysis into business value

There is little explicit business-metric framing or cost-of-error analysis; projects show engineering-to-deliver models but limited connection to ROI, SLAs, or product-level impact reasoning.

Evidence

Finance_Proj_MLOps/notebook/exp-notebook.ipynb

Production_Grade_Enterprise_RAG-AgenticAI-/notebooks/03_evals.ipynb

Reproducibility & Notebook Hygiene

4/10

Clean, repeatable analysis

Reproducible elements exist (requirements, dotenv usage, CLI entrypoints, structured ingestion/training modules), but no pinned environment artifacts (lockfile), DVC/data versioning, or automated CI/tests were found.

Evidence

Production_Grade_Enterprise_RAG-AgenticAI-/requirements.txt

app/ingestion/processor.py

Production_Grade_Enterprise_RAG-AgenticAI-/notebooks/03_evals.ipynb

Expertise

Big Data• Middle

Data Science• Middle

Industries

Artificial Intelligence• Middle

Financial Services• Middle

Technologies

Jupyter Notebook

Scikit-learn• since 2026

Pandas

NumPy

Streamlit

Pydantic

Boto3

Recommendations

Drive production RAG and retrieval systems: ingestion, embedding orchestration, vector DB indexing, and retrieval re-ranking pipelines (use the ingestion/processor.py and qdrant integration as baseline).
Build MLOps delivery for structured ML workloads: training pipelines, model promotion, artifact storage and evaluation automation (leverage the ModelTrainer/ModelEvaluation components and S3 integration).
Implement evaluation and monitoring suites for LLM/RAG systems: judge LLM metrics, tool-correctness checks, guardrails tests and periodic automated re-evaluation (use notebooks/03_evals.ipynb as a template).
Harden reproducibility and governance: add pinned dependency manifests, CI tests, data versioning (DVC), and explicit secret handling for API keys to make deployments auditable and safe.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

mohdsarfarazullakhan Production_Grade_Enterprise_RAG-AgenticAI- Finance_Proj_MLOps