Computer Vision Developer
12+ years exp
8+ years ML exp
Management: 6-10 years (1-5 people)
Python
C
MATLAB
C++
Scalability & Performance: 4/10
System Architecture: 4/10
Reliability & Observability: 4/10
Active 3 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A mid-level computer-vision-focused backend engineer specializing in real-time edge AI detection and integrated Streamlit UIs. The strongest proven skill is building a threaded detection pipeline and event-alert flow as shown by YardGuard-AI/detector.py and YardGuard-AI/alerts.py which implement model reuse, thread-safe state, scheduling, cooldowns, and background alert dispatch. Public code lacks evidence of database-backed persistence, CI/test coverage, cloud production hardening, or secrets management best practices.
Phone
Technical skills
Languages
4
Python
C
MATLAB
C++
AI/ML
8
Detectron2
Machine Learning
PyTorch
Hugging Face
NumPy
OpenCV
YOLO
Streamlit
Other
21
ROS2
ROS
Requests
Amazon SageMaker
Scikit-learn
TensorFlow
PyTorch C++
TensorFlow C++
Keras
arXiv
Docker
Git
Linux
Fine-tuning
Sensor Fusion
Edge AI
Multimodal AI
Computer Vision
OCR
Transfer Learning
Image Segmentation
Timeline
Senior Computer Vision Engineer
•
Senior
Aceris Optimage Services Inc.
•
Full-Time
Develops computer-vision and image-processing solutions for semiconductor inspection, metrology, and precision imaging with an emphasis on robustness and production usability. Builds and evaluates Python and C++ vision pipelines for preprocessing, detection/segmentation analysis, calibration, validation, and performance characterization. Investigates failure cases tied to imaging variability and data quality, refining algorithms and evaluation procedures for reliable operation. Works with engineering teams to transition R&D methods into maintainable workflows and documentation.
Python
C
Research Officer - Connected and Autonomous Vehicles
•
Middle
National Research Council Canada
•
Full-Time
Developed and evaluated deep-learning computer-vision systems for 3D object detection, scene understanding, driver monitoring, and multimodal perception using RGB/IR cameras, LiDAR, and vehicle/physiological signals. Performed dataset preparation, augmentation, model training and fine-tuning, validation, and failure analysis in PyTorch. Used Hugging Face and Detectron2 in project work and integrated models into NVIDIA Jetson Xavier/Orin with ROS/ROS2-based systems for real-time experimentation and deployment validation. Supervised and mentored graduate students and contributed to invention disclosure and technical outputs in multimodal AI.
Python
ROS
ROS2
PyTorch
Detectron2
Hugging Face
Research Scientist - Computer Vision & Deep Learning
•
Middle
Centre de géomatique du Québec
•
Full-Time
Developed computer-vision and deep-learning methods for UAV imagery, remote sensing, and geospatial image analysis for field-deployed use cases. Worked with large georeferenced datasets, focusing on registration, coordinate-aware processing, spatial measurements, and quantitative model evaluation. Built Python-based experimental pipelines and collaborated with geomatics teams to translate research into practical image-analysis workflows. Improved robustness by addressing acquisition variability through preprocessing, data curation, model refinement, and validation.
Python
Postdoctoral Researcher - Computer Vision & Deep Learning
•
Head+
Université du Québec à Chicoutimi (UQAC)
•
Full-Time
Designed and trained deep-learning vision models using a large, self-collected image corpus exceeding 500,000 images. Built reproducible data preparation, augmentation, training, validation, and benchmarking workflows for large-scale computer-vision experiments. Performed model comparison and error analysis to iteratively improve robustness and generalization on real-world imagery. Managed experimental repeatability and systematic evaluation across runs.
Postdoctoral Researcher - Computer Vision & Machine Learning
•
Head+
Bahcesehir University
•
Full-Time
Worked on OCR and assistive vision, AR/VR imaging, real-time nonlinear image recomposition, and medical/military image analysis research. Developed classical and deep-learning image-processing pipelines for tasks such as segmentation-oriented analysis, enhancement, recognition, and real-time vision components. Focused on building end-to-end experimental pipelines for different imaging modalities and performance scenarios. Conducted research experiments to support iterative method refinement.
Research Scientist / Graduate Research Assistant
•
Middle
Universiti Sains Malaysia
•
Full-Time
Researched image segmentation, illumination correction, local contrast enhancement, biomedical imaging, and machine-learning methods, contributing to peer-reviewed publications. Developed MATLAB, Python, and C++ image-processing algorithms with quantitative benchmarking and reproducibility as key evaluation practices. Supported undergraduate teaching in C++ programming and electrical system design, including labs, debugging, and technical guidance. Conducted research-driven experimentation focused on rigorous performance measurement.
Python
C
MATLAB
Universiti Sains Malaysia (USM)
Doctoral Degree (PhD) •
Image Processing & Machine Learning
AL-Mansour University College
Bachelor's Degree •
Computer Software Engineering
Senior Backend Developer
Confidence: High Generalist
A mid-level computer-vision-focused backend engineer specializing in real-time edge AI detection and integrated Streamlit UIs. The strongest proven skill is building a threaded detection pipeline and event-alert flow as shown by YardGuard-AI/detector.py and YardGuard-AI/alerts.py which implement model reuse, thread-safe state, scheduling, cooldowns, and background alert dispatch. Public code lacks evidence of database-backed persistence, CI/test coverage, cloud production hardening, or secrets management best practices.
API Design
3/10
How well APIs are designed
Minimal formal API design; uses external HTTP APIs (Telegram) and background alert dispatch but no explicit versioning, idempotency, or error-contract design.
Evidence
YardGuard-AI/alerts.py:_send_telegram (requests.post to Telegram Bot API)
YardGuard-AI/alerts.py:send (background thread dispatch of alert channels)
YardGuard-AI/app.py:alert_callback (invokes AlertManager.send from detector thread)
Data Layer & Database
1/10
Working with databases
No database or migration history; configuration persisted to YAML with a defensive deep-merge, but no transactional guarantees or schema evolution artifacts.
Evidence
YardGuard-AI/config_manager.py:load / save (yaml dump/load)
YardGuard-AI/config_manager.py:_deep_merge (merging on-disk config with defaults)
Scalability & Performance
4/10
Handling load and speed
Practical performance and scalability choices for an edge CV app: model reuse, FPS throttling, cache_resource for cross-thread queue and threaded alerting; not a distributed, large-scale system but well tuned for local realtime workloads.
Evidence
YardGuard-AI/detector.py:_run (model reload only when path changes; frame throttling to target FPS)
YardGuard-AI/app.py:_get_event_queue (st.cache_resource deque used to bridge detector thread and Streamlit main thread)
YardGuard-AI/detector.py (model loaded once per DetectionEngine instance; reloaded only when changed)
System Architecture
4/10
Overall system structure
Clear separation of concerns and module boundaries (UI, detector, alerts, config manager) and deliberate in-process integration choices; designed as a single-process, modular edge application rather than microservices.
Evidence
YardGuard-AI/detector.py:DetectionEngine (background thread, locking, public API methods)
YardGuard-AI/alerts.py:AlertManager (encapsulates email and Telegram channels)
YardGuard-AI/app.py (Streamlit UI wiring, session_state and lifecycle integration)
Security & Auth
2/10
Protecting data and access
Basic awareness of credentials and opt-in alerts but weak secrets hygiene and no strong input sanitization or explicit protections against common threats; credentials are expected to be stored in plaintext YAML.
Evidence
YardGuard-AI/alerts.py:_send_email (reads SMTP sender/password from config and logs warnings on missing creds)
YardGuard-AI/config_manager.py:DEFAULT_CONFIG (includes email.password and telegram.bot_token fields)
Reliability & Observability
4/10
Stability and monitoring
Reasonable reliability patterns for an edge service: thread-safe state with locks, error handling around camera and model load, logging, alert cooldown and graceful stop with thread join; limited automated retry/backoff strategies beyond simple cooldowns.
Evidence
YardGuard-AI/detector.py:use of threading.Lock and get_latest() copying under lock
YardGuard-AI/detector.py:_run (try/except around model load and loop errors with logging and status updates)
YardGuard-AI/detector.py:stop (sets _running False and joins thread with timeout)
Expertise
Backend AI & LLM• Middle
Python• Middle
System Architecture• Middle
Industries
Software• Middle
Technologies
Python• since 2014 • Senior
Requests
Recommendations
- Develop realtime edge-AI features and prototype detection pipelines (threaded inference, model hot-reload, zone logic).
- Implement production hardening tasks: secrets management (avoid plaintext YAML for credentials), structured logging, and graceful shutdowns with observability hooks.
- Productize alerting integrations with robust retry/backoff, idempotency and failure handling for external APIs (Telegram, SMTP).
- Add automated tests and CI, and introduce optional persistence (append-only event store or lightweight DB) for historical audit and schema migrations.
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 Generalist
Computer vision engineer (middle level) building local, inference-first detection applications with pragmatic system and UI integration as the strongest ability. The strongest proven skill is building a multithreaded inference and alerting pipeline that runs YOLO for live detection and integrates with Streamlit and asynchronous email/Telegram alerts, demonstrated by YardGuard-AI/detector.py and YardGuard-AI/alerts.py. There is no evidence of custom model training, experiment tracking, or production-grade MLOps such as CI/CD, monitoring or quantized/instrumented serving in the public code.
Model Architecture & Training
2/10
How well models are designed and trained
Inference-focused model usage is implemented and hot-reloadable, but there is no model architecture design or training pipeline.
Evidence
YardGuard-AI/detector.py: YOLO model is loaded (self._model = YOLO(model_path)) and conditionally reloaded when config changes
Data Pipeline & Feature Engineering
2/10
How data is prepared for models
Basic data handling and filtering at inference time; configuration merging for defaults is present but there is no dataset pipeline or augmentation logic.
Evidence
YardGuard-AI/config_manager.py: _deep_merge merges on-disk config with DEFAULT_CONFIG
YardGuard-AI/detector.py: model invocation uses classes=cfg_det.get('classes', [0]) to filter detections
Experimentation & Evaluation
1/10
How results are measured and tested
Minimal experimentation or evaluation tooling; only runtime metrics (FPS) and basic logging are present without reproducible experiment tracking or validation pipelines.
Evidence
YardGuard-AI/detector.py: fps accounting (self._fps_actual) and logging in the detection loop
MLOps & Deployment
3/10
How models are shipped to production
Reasonable inference-serving concerns and local deployment readiness via a Streamlit UI, runtime config management, model hot-reload and background alerting threads; no formal CI/CD or monitoring stack.
Evidence
YardGuard-AI/app.py: st.cache_resource used to share detector and event queue across Streamlit reruns
YardGuard-AI/config_manager.py: load/save persisted YAML config
YardGuard-AI/alerts.py: asynchronous alert delivery via background threads
Computational Efficiency
3/10
How efficiently computing resources are used
Practical runtime optimizations for inference such as single model load, framerate throttling and camera property tuning; no measured efficiency experiments or quantization.
Evidence
YardGuard-AI/detector.py: model loaded once and reloaded only on path change; loop throttles to target FPS (time.sleep based)
YardGuard-AI/detector.py: cap.set used to request width/height/fps from the camera
Research Depth & Innovation
1/10
Depth of research and new ideas
No research-level contributions or novel algorithm development; implementations are pragmatic and application-oriented.
Evidence
YardGuard-AI/detector.py: virtual fence implemented with cv2.pointPolygonTest for point-in-polygon checks
Expertise
Computer Vision & Image Analysis• Middle
Edge AI & On-Device ML• Middle
Technologies
C++• since 2026 • Junior
MATLAB• since 2014
YOLO
Fine-tuning• since 2026
Scikit-learn
Multimodal AI
Computer Vision• since 2026
Transfer Learning
Detectron2• since 2024
TensorFlow
NumPy
Keras
Git
PyTorch• since 2024
Docker
TensorFlow C++
PyTorch C++
Image Segmentation
Hugging Face• since 2024
Amazon SageMaker
OCR• since 2026
Edge AI
arXiv
Linux
Machine Learning• since 2018
Recommendations
- Develop edge-focused CV prototypes and POCs that require live camera ingestion, virtual-fence logic and alerting integrations.
- Harden the inference service for production: add unit/integration tests, CI/CD, secure secret management and structured logging/metrics.
- Extend the current work to measured efficiency improvements such as quantization, batch inference, or lightweight model alternatives with before/after benchmarks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Data Scientist
Confidence: Low ML Practitioner
A junior ML practitioner building simple computer-vision inference demos and interactive Streamlit pages. The strongest proven skill is delivering a Streamlit video inference UI that reads uploaded videos and displays annotated frames as shown in pedestrian-detector/pages/2_Video.py. There is little evidence of model training, evaluation, production deployment, testing, or data-pipeline engineering in public code.
Statistical Rigor
1/10
Correct use of statistics
No statistical analysis, hypothesis testing, uncertainty quantification or causal checks are present; the code is an inference/visualization page only.
Evidence
pedestrian-detector/pages/2_Video.py: video upload and frame loop with no statistical analysis or tests
Data Wrangling & Cleaning
2/10
Preparing and cleaning data
Minimal data handling is implemented (saving upload to a temp file and reading via OpenCV) but there is no explicit cleaning, outlier handling, provenance metadata, or leakage prevention.
Evidence
pedestrian-detector/pages/2_Video.py: tempfile.NamedTemporaryFile usage and cv2.VideoCapture loop
Exploratory Analysis & Visualization
2/10
Exploring and visualizing data
There is basic visualization of annotated frames for user feedback, but no exploratory data analysis, interpretation, or data storytelling.
Evidence
pedestrian-detector/pages/2_Video.py: frame_placeholder.image used to show annotated frames
Predictive Modeling
1/10
Building models that predict
Predictive/modeling work is not implemented in the human-authored file; the page calls an external detect_pedestrians function but contains no model training, evaluation, cross-validation or error analysis.
Evidence
pedestrian-detector/pages/2_Video.py: calls detect_pedestrians(frame) but contains no model code, evaluation or error analysis
Business Insight & Impact
1/10
Turning analysis into business value
There is no business framing, cost-of-error analysis, decision thresholds, or connection to KPIs in the code.
Evidence
pedestrian-detector/pages/2_Video.py: UI-focused page without business metrics or FP/FN tradeoff discussion
Reproducibility & Notebook Hygiene
1/10
Clean, repeatable analysis
Reproducibility and hygiene are minimal: no pinned environment files referenced from the execution code, no seeds, no tests or CI integration evident in the human-authored artifact.
Evidence
pedestrian-detector/pages/2_Video.py: single Streamlit page with no environment pinning or test hooks
Expertise
Data Science• Intern
Technologies
OpenCV
Streamlit
Recommendations
- Develop Streamlit-based computer-vision inference demos and refine the inference loop with batching, error handling and graceful upload failures.
- Implement model-loading and inference robustness in a single module (lazy load, caching, GPU fallback) and add unit tests for input handling and edge cases.
- Add reproducibility artifacts: pinned requirements, example inputs, a small test suite, and simple CI to validate pages on push.
- Build a small data collection and preprocessing pipeline for video frame extraction and labeling to demonstrate end-to-end dataset provenance.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
