Ahamed Ayyash
AI Engineer
Management: Under a year
20+ projects
Python
C++
SQL
JavaScript
C
API Design: 5/10
Data Layer & Database: 4/10
Scalability & Performance: 4/10
Active 3 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
Backend Python engineer (mid-level) focused on data profiling and ML pipelines with practical integrations to LLM agents. The strongest proven skill is building robust dataset profiling and analytics logic as implemented in app/services/profiler.py together with thorough unit tests in backend/tests/test_profiler_analytics.py. Production-grade concerns such as DB migrations, multi-service orchestration, comprehensive auth and runtime observability are not evidenced in the public code.
Phone
Technical skills
Languages
5
Python
C++
SQL
JavaScript
C
Python
7
Requests
FastAPI
Pydantic
SQLAlchemy
HTTPX
Flask
Uvicorn
Analytics
6
Matplotlib
Seaborn
Plotly
Power BI
Microsoft Excel
Tableau
AI/ML
19
OpenCV
LangChain
LLM
YOLO
NumPy
Pandas
Scikit-learn
Pillow
LangGraph
PyTorch
TensorFlow
Transformers
Keras
Unstructured.io
Embeddings
NLP
Prompt Engineering
RAG
Hugging Face
DevOps
3
Rest API
AWS
GitHub
Databases
3
PostgreSQL
Chroma
Pinecone
Other
19
Arduino Core
ESP-IDF
Adobe Photoshop
Xilinx Vivado
Proteus
React.js
TensorFlow C++
Jupyter Notebook
Recommender Systems
Docker
Git
Linux
AI Agents
Machine Learning
ETL/ELT
Dimensional Modeling
Multi-Agent Systems
Computer Vision
Time Series
Projects
TradeFlow AI - Multi-agentic Trade document resolver
An auditable AI agent platform that detects, investigates, and resolves trade-document and shipment exceptions, then verifies that the fix actually worked.
Telecom Customer Churn Analysis
Performed exploratory analysis and statistical review of telecom customer data to identify churn patterns. Built machine learning models for churn prediction and customer-risk segmentation, including cleaning, preprocessing, and feature engineering. Focused on extracting features that correlate with churn behavior and validating model effectiveness.
Shoplifting Detection System
Implemented a real-time object detection and tracking pipeline for video processing. Used YOLOv8-style detection with DeepSORT-style tracking, and applied OpenCV for video handling. Evaluated model performance in testing and reported detection accuracy above 90%.
EEG-Based Burnout Classification
Developed a data preparation and feature-processing pipeline for multichannel EEG data, including cleaning, preprocessing, and feature engineering. Trained and evaluated classification models to achieve about 92% accuracy. Worked on optimizing the model-training workflow to reduce training time as reported in the project.
DataPilot AI - Multi-Agent Data Analyst
Created a multi-agent data analysis application where LLM-powered agents process uploaded datasets. Automated analysis steps to generate interactive dashboards and written insights from raw data. Focused on reducing manual analysis by turning dataset uploads into actionable business intelligence outputs.
Interveuu - AI Interview & Candidate Evaluation Platform
Built an end-to-end AI platform that automates candidate interviews and evaluation as a final-year project. Developed LLM-driven interview and evaluation workflows in a Python/FastAPI backend, with REST APIs to connect AI steps into structured results. Integrated speech processing, NLP, and facial analysis, and connected outputs to a React frontend and MongoDB while testing and optimizing the pipeline for reliability.
Timeline
University of Engineering and Technology Taxila
Bachelor's Degree •
Computer Engineering
Software Engineer - AI & Full Stack
•
Middle
Nexura Tech (SMC) Pvt Ltd
•
Full-Time
Developed AI features and LLM-driven workflows for an automated interview and candidate evaluation platform. Built Python backend services and REST APIs to orchestrate speech processing, NLP, and facial analysis components. Integrated AI services with React frontend and MongoDB to deliver end-to-end functionality, and improved workflow reliability through testing, debugging, and performance troubleshooting.
Python
LLM
NLP
OpenCV
React.js
Machine Learning Head
•
Middle
AI Research and Development Society
•
Full-Time
Led machine learning mentorship and guided student AI projects through structured experimentation. Supported students in practical problem-solving and iterating on approaches based on testing results. Coordinated learning guidance with a focus on applied ML workflows.
Machine Learning Intern
•
Junior
Elevvo Pathways
•
Internship
Built recommendation systems in Python using collaborative filtering and content-based filtering for movies and music. Prepared and cleaned datasets, engineered features, and benchmarked models against baselines to improve relevance. Worked on handling cold-start scenarios to strengthen recommendation quality.
Python
Recommender Systems
Generative AI Application Developer Intern
•
Junior
Pak Angels
•
Internship
Developed generative AI applications using LLMs with prompt engineering and embeddings. Implemented RAG pipelines using LangChain and vector databases to retrieve relevant context for AI responses. Integrated model-driven functionality into application workflows via REST APIs, supporting reported reductions in manual effort and improved automation.
Python
LLM
Prompt Engineering
Embeddings
LangChain
RAG
Rest API
Undergraduate Reasearch Assistant
•
Middle
UET Taxila
Python
Statistics and Machine Learning Toolbox
Senior Backend Developer
Confidence: High Data Platform
Backend Python engineer (mid-level) focused on data profiling and ML pipelines with practical integrations to LLM agents. The strongest proven skill is building robust dataset profiling and analytics logic as implemented in app/services/profiler.py together with thorough unit tests in backend/tests/test_profiler_analytics.py. Production-grade concerns such as DB migrations, multi-service orchestration, comprehensive auth and runtime observability are not evidenced in the public code.
API Design
5/10
How well APIs are designed
Clear REST API built with FastAPI including pagination and file-upload handling, but lacks API versioning, standardized error contracts, idempotency keys, and consistent async/background execution patterns.
Data Layer & Database
4/10
Working with databases
Uses SQLAlchemy ORM models and scoped sessions for persistence and simple transactional flows; strong data-processing logic (DuckDB usage in agents) and analytical pipelines present, but no migration history or explicit transaction/isolation-level handling shown.
Evidence
ayyash1/datapilot-ai/backend/app/models/dataset.py: SQLAlchemy model definitions for Dataset/DatasetProfile
ayyash1/datapilot-ai/backend/app/api/datasets.py: uses SessionLocal and db.commit()/db.refresh() for persistence
ayyash1/datapilot-ai/backend/app/agents/sql_agent.py: imports duckdb for deterministic SQL execution
Scalability & Performance
4/10
Handling load and speed
Performance-aware ML code and pragmatic safeguards (file size limits, vectorized pandas operations, model n_jobs, early stopping), and LLM provider fallback strategy; lacks systematic caching, queue-based decoupling, rate limiting, or documented load-testing.
Evidence
ayyash1/freight-rate-prediction-challange/src/models.py: LightGBM/XGBoost/CatBoost defaults use n_jobs and early stopping parameters
ayyash1/datapilot-ai/backend/app/api/datasets.py: file size check (25MB) and immediate profiling comment about serverless runtimes
ayyash1/datapilot-ai/backend/app/agents/llm_provider.py: invoke_with_fallback implementing provider failover logic
System Architecture
4/10
Overall system structure
Modular separation between API, agents, profiler and ML pipeline with an orchestrator/agent-graph concept; architecture is monolithic rather than multi-service and lacks explicit service contracts and runtime orchestration (queues, circuit breakers) for production scale.
Evidence
ayyash1/datapilot-ai/backend/app/agents/graph.py: agent graph creation and routing between agents
ayyash1/datapilot-ai/backend/app/main.py: wiring FastAPI, CORS and DB Base.metadata.create_all
ayyash1/datapilot-ai/backend/app/agents/*: clear separation of supervisor, python_agent, sql_agent and evaluator modules
Security & Auth
3/10
Protecting data and access
Some boundary input validation (file type and size) and environment-based secret handling for LLM APIs, but missing authentication/authorization, token lifecycle management, thorough input sanitization and secrets/credentials rotation evidence.
Evidence
ayyash1/datapilot-ai/backend/app/api/datasets.py: file extension and size checks before accepting uploads
ayyash1/datapilot-ai/backend/app/agents/llm_provider.py: reads GEMINI_API_KEY and GROQ_API_KEY from environment and raises when missing
ayyash1/datapilot-ai/backend/app/api/chat.py: checks for dataset file existence and falls back to a sample file
Reliability & Observability
4/10
Stability and monitoring
Good local reliability practices: structured warnings/logging, unit tests for the profiler, and LLM provider failure classification; limited evidence of global observability (correlation ids, metrics/alerts), systematic retries/backoff, or graceful shutdown orchestration.
Evidence
ayyash1/datapilot-ai/backend/app/services/profiler.py: uses logger.warning/error and defensive try/except in profile_dataset
ayyash1/datapilot-ai/backend/tests/test_profiler_analytics.py: unit tests covering profiler behaviors and edge cases
ayyash1/datapilot-ai/backend/app/agents/llm_provider.py: collects failure reasons across providers for diagnostics
Expertise
Backend AI & LLM• Middle
Python• Middle
Industries
Artificial Intelligence• Middle
Data & Analytics• Middle
Transportation & Logistics• Senior
Technologies
Python• since 2025 • Senior
Rest API• since 2025
Flask
SQLAlchemy
FastAPI
Pydantic
HTTPX
Uvicorn
Requests
Recommendations
- Develop data ingestion and profiling microservices or APIs that expose schema evolution endpoints and migration histories.
- Implement queue-based async processing for large dataset profiling (e.g., background worker with idempotent jobs and result caching).
- Expand observability and reliability: add structured tracing/correlation ids, metrics/alerts, and retry/backoff policies for external LLM calls.
- Harden security and deployment ops: add authentication/authorization for APIs, secrets management, and DB migration tooling (Alembic).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer
Confidence: Medium Data-centric
A data-centric ML engineer (mid-level) specializing in practical applied ML and ETL with an emphasis on computer vision for industrial safety. The strongest proven skill is end-to-end computer-vision model training and deployment as seen in the YOLOv8 training notebook (training and validation steps) and the Streamlit inference app (load_model and process_frame). There is limited evidence of production-level MLOps (CI/CD, experiment tracking), custom model architectures, or systematic performance engineering in the public code.
Model Architecture & Training
3/10
How well models are designed and trained
Uses established model tooling (YOLOv8/Ultralytics) and trains/delivers models with sensible hyperparameters, but does not implement custom architectures, custom training loops, or non-trivial model engineering work.
Evidence
fire-and-smoke-detection-for-oil-industry-computer-vision-project/training_yolo.ipynb: model.train(...) with epochs,imgsz,batch and model.val()
fire-and-smoke-detection-for-oil-industry-computer-vision-project/app.py: load_model(model_path) using YOLO(model_path) and process_frame(frame, model, conf_threshold)
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Demonstrates practical ETL and feature preparation, including handling missing values, date feature extraction, categorical encoding and loading data into a Postgres warehouse via SQLAlchemy.
Evidence
telecom-customer-churn-analysis/notebooks/etl.ipynb: data preprocessing (fillna, date parsing, encoding) and feature selection
telecom-customer-churn-analysis/notebooks/etl.ipynb: SQLAlchemy DB creation and df.to_sql('stg_telecom_churn', engine, if_exists='replace')
Experimentation & Evaluation
3/10
How results are measured and tested
Runs basic evaluation and validation (sklearn metrics, YOLO val output) but lacks experiment tracking, reproducible experiment management, sweep/ablation design or automated CI for evaluations.
Evidence
telecom-customer-churn-analysis/notebooks/etl.ipynb: logistic regression and DecisionTree evaluation prints (accuracy, precision, recall, ROC-AUC)
fire-and-smoke-detection-for-oil-industry-computer-vision-project/training_yolo.ipynb: model.val() and printed Ultralytics validation outputs
MLOps & Deployment
4/10
How models are shipped to production
Provides a deployable Streamlit application with caching, temporary file handling, and live/video input handling, showing practical deployment and inference-serving considerations, though not a production-grade serving stack.
Evidence
fire-and-smoke-detection-for-oil-industry-computer-vision-project/app.py: st.cache_resource load_model and video/live camera processing loops
telecom-customer-churn-analysis/notebooks/etl.ipynb: use of environment variables for DB credentials and automated DB creation via SQLAlchemy
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to runtime performance (FPS calculation, caching model) and batch sizing in training, but no systematic profiling, quantization, GPU-memory optimizations or batching strategies beyond defaults.
Evidence
fire-and-smoke-detection-for-oil-industry-computer-vision-project/app.py: fps calculation around inference and use of st.cache_resource to avoid repeated reloads
training_yolo.ipynb: training settings (batch=8) and Ultralytics training log showing CUDA use and inference timing
Research Depth & Innovation
1/10
Depth of research and new ideas
No evidence of original research, novel algorithms, paper implementations, or advanced model innovation; work focuses on applied usage of existing tools and libraries.
Evidence
training_yolo.ipynb: uses Ultralytics YOLOv8 and Roboflow dataset download without custom model code or novel layers
Verified artifacts
Expertise
Industrial AI & Smart Manufacturing• Middle
Industries
Energy & Utilities• Middle
Telecommunications• Middle
Technologies
SQL• since 2026 • Junior
C++• since 2026 • Junior
LangGraph
LangChain• since 2025
Unstructured.io
Chroma
Pinecone
Embeddings• since 2025
Prompt Engineering• since 2025
Computer Vision• since 2026
AI Agents
NLP• since 2025
Transformers
TensorFlow
NumPy• since 2026
Keras
Git
PyTorch
AWS• since 2026
Docker
LLM• since 2025
RAG• since 2025
TensorFlow C++
Pillow
Time Series
Hugging Face
GitHub
Recommender Systems• since 2025
Multi-Agent Systems
Linux
Machine Learning• since 2026
GitHub• mentioned only
Machine Learning• mentioned only
Recommendations
- Develop production-grade inference serving and monitoring: convert the Streamlit prototype into a containerized inference service with a proper REST/gRPC API, health checks, logging, and drift/alerting.
- Add experiment tracking and reproducibility: integrate W&B or MLflow, save hyperparameters and metrics, and create reproducible training recipes and configuration files.
- Harden deployment and security: remove hardcoded secrets (exposed API keys), add secret management, and formalize model/version packaging (artifacts, checksums).
- Improve evaluation and model selection: implement cross-validation, baseline comparisons, ablation studies and a validation pipeline that produces consistent metrics for deployment decisions.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Data Scientist
Confidence: Medium Data Engineer
A mid-level data engineering practitioner focused on end-to-end ETL and applied computer-vision prototypes for industrial use. The strongest proven skill is building a production-style Streamlit monitoring application that integrates a custom-trained YOLOv8 model for live fire and smoke detection as demonstrated by the industrial safety app and training notebook. Limited evidence exists for production-grade testing, CI/CD, large-scale distributed data infrastructure or formal MLOps practices.
Statistical Rigor
3/10
Correct use of statistics
Basic model evaluation metrics are reported but there are no rigorous assumption checks, limited cross-validation or uncertainty quantification; some honest negative results are printed but deeper statistical analysis is missing.
Evidence
telecom-customer-churn-analysis/notebooks/etl.ipynb: logistic regression prints Accuracy/Precision/Recall/ROC-AUC
fire-and-smoke-detection-for-oil-industry-computer-vision-project/training_yolo.ipynb: model.val() and training metrics printed
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Clear ETL and cleaning steps are implemented including missing-value imputation, date handling, encoding and staging to Postgres; SQL scripts implement dimensional modeling and some data validation (e.g., handling negative data_used).
Evidence
telecom-customer-churn-analysis/notebooks/etl.ipynb: missing-value fills, date parsing, gender encoding and df.to_sql to staging
telecom-customer-churn-analysis/sql/sql_script.sql: dim/fact table creation and CASE WHEN to fix negative data_used
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
There are dashboards and visual outputs (Power BI screenshots and plotted training results), but exploratory analysis in notebooks is minimal and lacks written interpretation after findings.
Evidence
telecom-customer-churn-analysis/README.md: Power BI dashboard screenshots described
fire-and-smoke-detection-for-oil-industry-computer-vision-project/training_yolo.ipynb: displays results.png after training
Predictive Modeling
4/10
Building models that predict
Predictive work includes training YOLOv8 and conventional ML models with baseline evaluations; however there is limited hyperparameter search, no robust CV schemes beyond a single train/test split, and minimal error analysis.
Evidence
fire-and-smoke-detection-for-oil-industry-computer-vision-project/training_yolo.ipynb: YOLO training (model.train) and validation
telecom-customer-churn-analysis/notebooks/etl.ipynb: logistic regression and decision tree training with train_test_split
Business Insight & Impact
3/10
Turning analysis into business value
Work is framed toward business use (churn dashboards, OLAP queries and industrial hazard monitoring) but there is limited explicit cost-of-error reasoning or actionable decision rules tied to business metrics.
Evidence
telecom-customer-churn-analysis/README.md: dashboard descriptions and churn drill-downs
telecom-customer-churn-analysis/sql/sql_script.sql: vw_monthly_churn view intended for BI consumption
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Some reproducibility practices are present such as a requirements.txt, use of environment variables for DB credentials and fixed random_state, but there is no evidence of CI/CD, data versioning, containerization or formal experiment tracking.
Evidence
telecom-customer-churn-analysis/requirements.txt: pinned minimal dependencies
telecom-customer-churn-analysis/notebooks/etl.ipynb: environment variables used for DB credentials and random_state in splits
Industries
Energy & Utilities• Middle
Telecommunications• Middle
Technologies
PostgreSQL
OpenCV• since 2025
Jupyter Notebook
YOLO
Scikit-learn• since 2026
Pandas• since 2026
ETL/ELT
Dimensional Modeling
Machine Learning• mentioned only
Power BI• mentioned only
Recommendations
- Develop end-to-end prototype monitoring systems that combine a CV model, a lightweight inference service and an operational UI for industrial safety or surveillance.
- Build ETL pipelines and dimensional data warehouses with clear CI/CD, automated tests and data validation for analytics teams.
- Lead ML deployment and MLOps work that adds reproducibility: containerized inference, model versioning, metrics logging and simple monitoring/alerting.
- Enhance statistical rigor and modeling by adding cross-validation, hyperparameter search, uncertainty quantification and documented error analysis for churn and predictive tasks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: