Mohamed Al Jalanji
LLM Developer
9+ years exp
9+ years ML exp
C++
C
SQL
Java
Python
Data Pipeline & Feature Engineering: 5/10
Experimentation & Evaluation: 4/10
Active 2 days ago
+33 (6) 59937888 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Data-platform focused developer (Middle) with a practical strength in building data ingestion and ETL pipelines for spatial/transportation datasets. The strongest proven skill is Postgres-backed ETL and schema construction demonstrated by pariscitymapper/parse/parse.py and pariscitymapper/parse/schema.py. There is little evidence of production-grade API design, CI/tests, migrations, or advanced scalability and observability practices.
Technical skills
C++
C
SQL• 9y+
Java• Middle • 6y+
Python• Middle
C++
PyTorch C++
Python
FastAPI
pySpark
SQLAlchemy
Databases
PostgreSQL
Databases
Neo4j
AI/ML
AgentOps
Claude
Claude Code
Cursor
DSPy
DVC
Fine-tuning
Knowledge Distillation
LangChain
Langfuse
LangGraph
LangSmith
LLM
MLFlow
NumPy
Time Series Forecasting
vLLM
Spark
Statsmodels
Pandas• 9y+
Scikit-learn• 9y+
PyTorch• 3y+
AWS Bedrock
Pydantic AI
RAG
Mobile
Android
Android SDK
ConstraintLayout
Material Design
JUnit
DevOps
Amazon EC2
Amazon EKS
AWS
CI/CD
Docker
Git
Terraform
Kubernetes
Rest API
QA
Postman
Analytics
Tableau• 9y+
Timeline
Data Scientist & AI Engineer (LLMs)
•
Middle
PrediSurge
•
Full-Time
Led the design and implementation of an agentic RAG pipeline over structured clinical data and PDF content. Worked with fine-tuned small language models and PydanticAI-based orchestration to run and evaluate the system. Built an AWS-backed integration for agentic RAG into the company SaaS using LLMOps-style prompt versioning, monitoring, and RAG evaluation.
RAG
Pydantic AI
AWS Bedrock
AI Engineer
•
Middle
APTIV
•
Full-Time
Developed constraint-based workflow designs to translate dataflow graphs into Logical Execution Time plans, reducing manual effort for automotive projects. Fine-tuned a CodeT5 model using PyTorch to generate commands for a local automobile platform and built supporting evaluation metrics and parsers. Created a cloning tool for systematic duplication of AUTOSAR Classic elements using a Python approach to reduce execution errors in a sensor fusion use case.
PyTorch
ML Engineer Intern
•
Junior
ETIS lab (CNRS UMR 8051)
•
Internship
Applied an MPDist distance measure on linguistic burst time series data and used a dedicated library to construct distance matrices. Performed clustering validation using HDBSCAN and assessed the quality using a DBCV clustering score. Focused on end-to-end data preparation, modeling, and evaluation for the time-series clustering task.
Junior Data Scientist
•
Junior
PI Marketing
•
Full-Time
Built machine learning ensemble models for customer segmentation and predictive lead scoring to improve marketing campaign performance. Implemented data pipelines and modeling using common analytics tools and production query workflows. Visualized outcomes and insights in dashboards to support personalized outreach decisions.
Pandas
Scikit-learn
SQL
Tableau
Android Developer
•
Middle
Smart Source
•
Full-Time
Developed an Android application intended to improve clients’ operational efficiency. Implemented app features using an Android development workflow and integrated testing/requests tooling via Postman. Focused on delivering functional improvements for client operations through mobile software.
Middle AI/ML Engineer
Confidence: Medium Data-centric
Middle-level data-centric engineer specializing in motif-based time-series clustering and retail analytics. The strongest proven skill is applied time-series motif discovery and clustering, supported by the Time_Series_Analysis.ipynb pipeline using stumpy, custom distance functions, hypertuning and HDBSCAN evaluation. There is little evidence of production hardening, automated testing, experiment tracking or model serving in public code.
Model Architecture & Training
3/10
How well models are designed and trained
Custom clustering and distance code is present (DTW, MPDist wrappers, HDBSCAN tuning) but there is no evidence of custom model training loops, regularization strategies, or production-grade training pipelines.
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Substantial data preprocessing and feature engineering for time series is implemented, including regularization to fixed timeframes, KNN imputation, differencing for stationarity, resampling and normalization, plus a CSV-to-database ingestion script.
Evidence
Jalanjii/motif_clustering/Time_Series_Analysis.ipynb: timeframe merge, KNNImputer usage, resample('ME') aggregation and differencing for stationarity
basmaaitbelarbi/aws_migration/parser.py: reading retail_data.csv and building SQLAlchemy Table schema
Jalanjii/motif_clustering/Time_Series_Analysis.ipynb: z_normalize() and max_scaling() implementations
Experimentation & Evaluation
4/10
How results are measured and tested
Experimentation and evaluation are present through cluster validity metrics (DBCV, Dunn), hyperparameter search loops and comparative result reporting, but no formal experiment tracking or reproducible experiment configs are used.
Evidence
Jalanjii/motif_clustering/Time_Series_Analysis.ipynb: dunn_index_precomputed() and use of DBCV
Jalanjii/motif_clustering/Time_Series_Analysis.ipynb: hypertuning() loop evaluating multiple HDBSCAN settings and collecting best scores
Jalanjii/motif_clustering/Time_Series_Analysis.ipynb: results assembled into a DataFrame and visualized for comparison
MLOps & Deployment
1/10
How models are shipped to production
Minimal MLOps or deployment engineering; there are simple database connection checks and table creation scripts but no model serving, versioning, CI/CD or monitoring for models.
Computational Efficiency
2/10
How efficiently computing resources are used
Limited computational efficiency engineering: the author uses stumpy (efficient library) for matrix profile operations but also relies on naive Python loops for DTW and pairwise distance matrices, with no GPU, batching or profiling work.
Research Depth & Innovation
3/10
Depth of research and new ideas
Solid applied research knowledge in motif discovery and matrix profile concepts and a practical consensus-motif pipeline, but no evidence of novel algorithm design, formal benchmarks or peer-reviewed reproductions.
Expertise
MLOps & Model Lifecycle• Middle
Industries
Commerce• Middle
Technologies
Databases
Python• Middle
SQL• 9y+
C++
Cursor
LangGraph
DVC
Rest API
LangChain
Claude
Terraform
Neo4j
Spark
Claude Code
DSPy
SQLAlchemy
vLLM
MLFlow
FastAPI
Fine-tuning
Scikit-learn• 9y+
Knowledge Distillation
Langfuse
LangSmith
Pydantic AI
AgentOps
AWS Bedrock
CI/CD
Pandas• 9y+
NumPy
Git
PyTorch• 3y+
AWS
Docker
Kubernetes
LLM
RAG
pySpark
PyTorch C++
Statsmodels
Amazon EKS
Amazon EC2
Time Series Forecasting
Recommendations
- Develop prototype time-series clustering and motif-discovery analyses and visualizations for retail or demand-forecasting use cases.
- Build data ingestion and ETL pipelines that persist cleaned features into AWS RDS and downstream analytics stores.
- Turn exploratory notebooks into modular, testable Python packages or scripts with parameterized configs and reproducible experiment runs.
- Implement lightweight experiment tracking (e.g., MLflow or W&B) and add basic CI to validate data transforms and evaluation metrics
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium Data Platform
Data-platform focused developer (Middle) with a practical strength in building data ingestion and ETL pipelines for spatial/transportation datasets. The strongest proven skill is Postgres-backed ETL and schema construction demonstrated by pariscitymapper/parse/parse.py and pariscitymapper/parse/schema.py. There is little evidence of production-grade API design, CI/tests, migrations, or advanced scalability and observability practices.
API Design
1/10
How well APIs are designed
No HTTP/REST/GraphQL API design or versioning; the project is a GUI-driven desktop app and ingestion scripts rather than a designed API surface.
Evidence
pariscitymapper/parse/main.py: application is a PyQt GUI and does not expose REST/GraphQL endpoints
pariscitymapper/parse/parse.py: ETL functions exist but are not wrapped as service APIs
Data Layer & Database
4/10
Working with databases
Clear data-layer work: an explicit SQL schema with PK/FK, use of SQLAlchemy and psycopg2, ETL via pandas.to_sql and basic transaction handling; lacks migration history, batching or advanced tuning.
Evidence
pariscitymapper/parse/schema.py: sql_schema string with create table, primary key and foreign key definitions
pariscitymapper/parse/parse.py:create_nodes and create_temporal_day use pandas and copy_to_db -> to_sql
pariscitymapper/parse/main.py: create_engine(...) and psycopg2 connection usage with commit/rollback handling
Scalability & Performance
2/10
Handling load and speed
Minimal scalability/performance engineering: in-memory pandas operations and to_sql calls without batching or background workers; no caching, queuing, or documented pooling/tuning.
Evidence
pariscitymapper/parse/parse.py: uses pandas.read_csv and df.to_sql without batching or chunking
pariscitymapper/parse/main.py: synchronous UI-driven DB queries and processing on the main thread
System Architecture
3/10
Overall system structure
Reasonable module separation for a small monolith (params, parse, schema, UI) but overall architecture is a single-process desktop ETL/GUI without service decomposition or config/secret management best practices.
Evidence
pariscitymapper/modules/params.py: central configuration read/write for DB and data path
pariscitymapper/parse/main.py and pariscitymapper/parse/parse.py: separation between UI (MainWindow) and ETL logic (parse.py)
Security & Auth
2/10
Protecting data and access
Basic security awareness but risky patterns: credentials are accepted via UI and written to a JSON file and SQL is constructed with f-strings in places; limited input sanitization and no credential lifecycle controls.
Evidence
pariscitymapper/modules/params.py: set_variables writes DB credentials to ../modules/params.json
pariscitymapper/parse/main.py: SQL queries built with f-strings (e.g. SELECT stop_i FROM nodes WHERE name = '{self.to_stop_i}') with only ad-hoc single-quote replacement
Reliability & Observability
2/10
Stability and monitoring
Some basic reliability handling (try/except, commit/rollback) is present but there are no structured logs, metrics, retries with backoff, or test coverage and graceful shutdown patterns.
Evidence
pariscitymapper/parse/main.py: connect_DB uses try/except with conn.rollback and re-invokes parse.main() on missing tables
pariscitymapper/parse/parse.py: copy_to_db catches DB errors and performs conn.rollback
Expertise
Python• Middle
Databases & Vector Storage• Middle
Java• Middle
Industries
Transportation & Logistics• Middle
Technologies
PostgreSQL
Recommendations
- Develop ETL and ingestion pipelines for transit or GIS datasets where Postgres and pandas are primary tools, adding batching and chunked writes
- Extend the existing data tooling into a headless backend service with a proper API, migrations and CI to enable production deployment
- Harden database interactions: replace f-string SQL with parameterized queries, add credential management and secrets handling
- Add automated tests, structured logging and simple observability (metrics/traces) to make pipelines production-ready
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Mobile Developer
Confidence: Medium Android Engineer
Android developer (Middle) focused on interactive image editing and custom canvas-based UI with a strength in implementing algorithmic image processing and visualization. The strongest proven skill is custom UI and algorithm implementation, demonstrated by CurveView.java (bezier spline interaction) and GaussianBlur.java (heavy-weight blur algorithm). There is limited evidence of modern lifecycle-aware concurrency, performance profiling, structured background work or release/CI practices in public code.
Platform Native Mastery
2/10
Knowing the mobile platform
Basic platform usage and fragment lifecycle handling present but missing robust state restoration, modern structured concurrency and comprehensive permission flows; background work uses AsyncTask instead of lifecycle-aware coroutines or WorkManager.
Mobile UI/UX & Responsiveness
4/10
Smooth mobile experience
Shows solid custom UI work with interactive custom Views, touch handling and drawing (bezier curves and grid), but lacks adaptive layouts, accessibility, RTL or dynamic type handling.
Evidence
Jalanjii/imageeditor/app/src/main/java/com/example/ImageEditor/Spline/CurveView.java: custom View drawing bezier curves and touch-based point edit
Jalanjii/imageeditor/app/src/main/java/com/example/ImageEditor/AstarAlgorithm/GridView.java: interactive grid custom View with drawing and touch tile editing
Performance & Battery
2/10
Speed and battery use
Implements non-trivial image processing algorithms in Java showing algorithmic understanding, but no performance measurements, native acceleration, or modern background execution; potential CPU-heavy work on the UI thread in places and no profiling evidence.
Offline & Data Sync
Working offline and syncing
Not evidenced in public code
Device Integration
3/10
Using device features
Contains basic device integration patterns for image picking and an explicit permission-check fallback, but the full permission rationale/settings redirect and other device integrations are not fully evidenced in the provided artifacts.
Release & App Lifecycle
1/10
Building and publishing apps
Project contains standard Gradle configuration files but lacks CI, release automation, signing configuration or crash/reporting integration in the visible files.
Expertise
Android• Middle
Industries
Media & Entertainment• Middle
Technologies
Android
Java• Middle • 6y+
JUnit
Android SDK
Material Design
ConstraintLayout
Recommendations
- Assign to build interactive Android features that require custom Views, touch input and canvas drawing such as drawing editors, annotation tools or visualization prototypes.
- Use to implement on-device image filters or algorithmic photo features where Java-based algorithms need integration into the UI and simple background execution.
- Pair with a senior engineer to modernize background execution and lifecycle handling - migrate AsyncTask to coroutines/WorkManager, add state restoration and performance profiling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: