Computer Vision Engineer β’ Data Scientist β’ ML Engineer β’ Analytics Architect
Building MonitEye β real-time video analytics that turns camera feeds into decisions
I build computer vision systems that run around the clock on real hardware, in real factories and buildings. Most of my time goes to MonitEye, our video analytics platform, where the question is never just "can the model detect this" but "can it keep detecting it on 25 cameras at once, for months, without crying wolf." That constraint shapes how I work: production first, measurement over intuition, and a bias toward systems someone else can operate.
The rest of my background is the data lifecycle around it β forecasting, statistical modeling, experimentation and the pipelines that keep any of it alive in production. Vision is where I go deep; the analytics side is what lets me turn a detection into a number a business can act on.
MonitEye is the platform I build: a real-time video analytics system that watches live camera streams and reports what matters β a worker without a helmet, someone on the floor, a forklift too close to a person, smoke before it becomes fire, a defective part on the line, how many visitors walked through the door and who they were. More than 30 analytics modules run on it today, across occupational safety, quality control and production monitoring.
Architecture. Every module is a handler bound to a polygon on a camera, with its own thresholds and model. A central manifest maps module types to handlers and categories, so a deployment can be built with only the module families a site actually needs β the rest is stripped before the image is even compiled. Cameras are read by asynchronous capture threads with RTSP reconnect, annotated frames are streamed to the UI over MJPEG, and events land in PostgreSQL with the violation clip attached.
Sharing one GPU. A global model manager keeps a single copy of each network in VRAM so dozens of modules can share YOLO11 detection and pose, RF-DETR, and CLIP without loading the same weights twice. Every camera schedules itself: processing time is measured continuously and the frame-skip rate adapts to it, so a fast machine analyzes more frames and a loaded one degrades gracefully instead of falling behind. Inference timing, VRAM and CPU load are logged per model, which makes performance a measurement rather than an argument.
The part that isn't the model. A detector firing is not an event. Turning detections into something worth alerting on is tracking with persistent identities, line-crossing and zone geometry, dwell and duration thresholds, temporal voting so one bad frame never raises an alarm, cooldowns so one incident isn't reported forty times, and pre/post-roll clips so a human can verify what happened. When there's no labeled data for an attribute, vision-language models fill the gap: CLIP over full-body crops with weighted, distance-aware voting, locked only once the evidence is decisive.
Shipping it. Everything runs as a Dockerized CUDA image on customer hardware, with the critical modules compiled to native extensions so the source never leaves our side. I tune this the same way I tune models: profile each stage, change one thing, and re-validate the counts against labeled footage before calling it faster.
The discipline behind the platform above. I work across detection and multi-object tracking (YOLO11, RF-DETR, Detectron2, Faster R-CNN, ByteTrack, DeepSORT), 17-keypoint pose estimation for posture, falls and ergonomics, semantic and instance segmentation, anomaly detection on visual streams, and vision-language models such as CLIP for zero-shot attributes where no labeled dataset exists β and where the honest answer is often that the model is only reliable at certain distances, which is itself something to measure and design around.
Accuracy is half the job. The other half is making it run: multi-model inference sharing one GPU, resolution and model-size trade-offs measured rather than guessed, adaptive frame scheduling per camera, quantization and compression for edge boxes, and Dockerized CUDA deployment. My default loop is profile β change one thing β re-validate against labeled footage, because a speedup that quietly moves a count is not a speedup.
Skills: OpenCV Β· PyTorch Β· YOLO11 Β· YOLO26M-Pose Β· RFDETRv2 Β· Detectron2 Β· Faster R-CNN Β· ByteTrack Β· DeepSORT Β· Supervision Β· OpenCLIP Β· Transformers Β· EasyOCR Β· Shapely Β· CUDA Β· Docker Β· Flask Β· PostgreSQL
Machine learning, deep learning and generative AI pointed at decisions rather than leaderboards. I build predictive and forecasting models β time-series work with ARIMA, Prophet and LSTMs β alongside the statistical modeling, hypothesis testing and feature engineering that make them trustworthy. Ensembles and model stacking when accuracy pays for the complexity; disciplined A/B testing and experiment design to prove the model changed something worth changing.
Skills: PyTorch Β· TensorFlow Β· Scikit-learn Β· XGBoost Β· LightGBM Β· Statsmodels
I own the whole path from notebook to production: ML pipeline architecture, data engineering and ETL workflows, model versioning and registries, CI/CD automation, and scalable infrastructure on Docker and Kubernetes across AWS, GCP and on-premise hardware. Shipping is only half of it β keeping a system healthy is where the work really lives, so monitoring, logging and observability, high availability and disaster recovery are part of the design from the start, not bolted on after the first incident.
Skills: Docker Β· Kubernetes Β· GitHub Actions Β· AWS Β· GCP Β· PostgreSQL Β· Redis Β· Airflow
Python, SQL and PyTorch are where I'm fastest. Around them: Pandas, NumPy, Polars and Dask for data processing; Statsmodels, SciPy and Scikit-learn for statistical modeling; PyTorch, TensorFlow and Keras for deep learning; Matplotlib, Seaborn and Plotly when a chart has to carry an argument; PostgreSQL, MySQL, MongoDB and vector databases for storage; Spark and Hadoop when the data outgrows one machine; FastAPI, Flask and Django to put the result behind an endpoint β all of it version-controlled through Git and GitHub workflows.
Time-series forecasting with ARIMA, Prophet, LSTMs and Transformers, applied where a number has consequences: demand forecasting and inventory optimization, churn and customer lifetime value, price elasticity, revenue prediction, and anomaly detection on streams where "unusual" has to be defined before it can be caught.
Before modeling comes understanding β profiling, EDA, and an honest look at missing values, outliers and imbalanced distributions. From there: feature extraction and dimensionality reduction (PCA, t-SNE), statistical, correlation and importance-based selection, interaction and polynomial features, and domain-specific features that only exist because someone asked the right question about the business.
Binary, multi-class, multi-output and hierarchical classification; linear, non-linear and ensemble regression. The details that decide whether a model survives contact with reality: imbalanced data handled with SMOTE, class weights and threshold tuning, calibrated probabilities instead of raw scores, and cross-validation strategies that match how the model will actually be used.
Experimental design and power analysis first, then A/B testing frameworks with guardrail monitoring, multivariate and adaptive experiments, and multi-armed or contextual bandits when traffic is too valuable to split evenly. Where randomization isn't possible, causal inference takes over β propensity matching, DAGs, CATE estimation β alongside significance testing, confidence intervals and Bayesian approaches.
Text preprocessing and tokenization through to sentiment analysis, named entity recognition, classification and topic modeling. Embeddings from Word2Vec, GloVe and FastText where they still earn their keep, transformer models like BERT and GPT where they don't, and LLM applications and fine-tuning for problems that resist a fixed label set.
Collaborative filtering (user- and item-based), content-based and hybrid approaches, matrix factorization and factorization machines, and neural collaborative filtering when the signal justifies it β plus the two problems that decide whether a recommender ships: cold start and real-time serving.
K-means, hierarchical clustering and DBSCAN, Gaussian mixture models with EM, dimensionality reduction via PCA, t-SNE and UMAP, and anomaly detection with Isolation Forest or one-class SVM. Most often in service of customer segmentation and micro-segmentation, or topic modeling with LDA and NMF.
CNNs for images, RNNs, LSTMs and GRUs for sequences, attention mechanisms and Transformers where context matters, autoencoders and VAEs for representation and anomaly work, and the basics of generative models. Transfer learning and domain adaptation to avoid training from scratch, then quantization and pruning to make the result fit the hardware it has to run on.
Interactive dashboards and reporting in Tableau, Power BI and Plotly, real-time monitoring views, and BI with KPIs that someone actually acts on. The harder half is narrative: turning an analysis into a decision a stakeholder can defend, with statistical visualization done honestly rather than persuasively.
Model versioning and registries with MLflow and DVC, CI/CD pipelines through GitHub Actions and Jenkins, serving and inference optimization, A/B infrastructure with canary deployments, and the monitoring, drift detection and retraining automation that keeps a deployed model from quietly becoming wrong.
Data quality frameworks and profiling, lineage and metadata management, validation and schema enforcement, master data management, and cataloging that makes data discoverable β under privacy and compliance requirements such as GDPR and CCPA.
| Area | Expertise |
|---|---|
| Predictive Modeling | End-to-end model development, validation, deployment |
| Time-Series Analysis | Forecasting, anomaly detection, trend analysis |
| Feature Engineering | Domain-driven features, statistical selection |
| Model Optimization | Hyperparameter tuning, ensemble methods, SHAP analysis |
| A/B Testing | Experimental design, statistical rigor, insights |
| Production ML | Model serving, monitoring, retraining pipelines |
| Data Visualization | Dashboards, reports, executive summaries |
| Team Leadership | Mentoring, knowledge sharing, best practices |
"The best model is the one that drives business decisions and creates measurable impact. Complexity is cheapβsimplicity that works is priceless."
In practice that means understanding why a model predicts what it does before trusting it, validating rigorously instead of hoping, and automating until the pipeline is repeatable by someone who isn't me. It means translating results for the people who have to act on them, taking fairness and responsibility seriously in what ships, and proving value with metrics rather than adjectives.
A fall detection system running on 25 live camera streams in real time. A demand forecasting model that improved inventory accuracy by 35%. An A/B testing framework supporting 100+ concurrent experiments. An ML pipeline scaled from 10K to over 1M predictions per day β and 5+ data scientists mentored along the way.
Always learning. Always shipping. Always creating impact.
Last updated: July 2026