Ayush Lokare
ML Engineer
6+ years ML exp
Python
MLOps & Deployment: 5/10
Research Depth & Innovation: 4/10
Active 2 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Phone
Technical skills
Languages
1
Python
Python
5
SQLAlchemy
Asyncio
FastAPI
Pydantic
Alembic
AI/ML
12
ResNet
LLM
NumPy
Pandas
OpenCV
TF-Keras
AutoGen
Claude
LangChain
LangGraph
TensorFlow
CrewAI
Other
34
ROS
Gazebo
PostgreSQL
Azure
Redis
HTTPX
RAG
Weaviate
Chroma
Hugging Face
Deep Learning
GitHub
GitHub Actions
Uvicorn
Computer Vision
LLM Guardrails
LangSmith
Docker
Git
Rest API
Docker Compose
Vector
Claude Code
Model Context Protocol
Transfer Learning
AI Agents
CI/CD
Containers
Embeddings
OCR
NLP
Context Engineering
Human-in-the-Loop
Function Calling
Timeline
Applied AI Engineer
•
Middle
GSK
•
Full-Time
AI/ML Engineer 06/2025 - Present Bengaluru, KA, India • Lead engineer (80% commits) on an end-to-end LLM workflow for pharma regulatory change assessment across 8 countries - ensuring self-consistency (parallel inference with majority voting), semantic matching against historical submissions, and automated report generation. • Achieved 85%+ agreement with subject-matter experts on SME defined output fields. Developed task-specific LLM workflow DAG and building the retrieval layer end-to-end (chunking, embedding generation, retrieval, vector index creation/population), prototyping fast and pruning approaches that underperformed. • Improved and safeguarded output quality with applied prompting and validation (structured multi-pass decomposition, policy-rule guardrails layered over LLM out
AI/ML Engineer
•
Middle
GSK
•
Full-Time
Led an end-to-end LLM workflow for pharma regulatory change assessment across multiple countries, focusing on self-consistent outputs and semantic matching to historical submissions. Built the retrieval pipeline end-to-end including text chunking, embedding generation, and vector index creation/population. Implemented quality control using structured multi-pass prompting and layered policy-rule guardrails, supported by internal SME-graded golden datasets and measurable evals.
LLM
RAG
LLM Guardrails
Vector
Georgia Institute of Technology (Georgia Tech)
Master's Degree •
Computer Sciences (OMSCS)
Deep Learning Intern
•
Junior
Infyuva
•
Internship
Developed deep learning methods to automate fetal head circumference measurement from ultrasound images using U-Net-based segmentation and systematic hyperparameter tuning. Applied transfer learning and used optimization techniques to improve model performance. Authored a research paper accepted at IEEE TENCON, leading study design, data analysis, and manuscript preparation.
Transfer Learning
PRISM Developer
•
Middle
Samsung R&D Institute India-Bangalore (SRI-B)
•
Full-Time
Worked on a variant of the m-coloring graph problem for optimal camera placement around stages. Modeled coverage while accounting for physical obstacles and constraints to support placement decisions. The team received a cash reward for top-performing work.
Perception Subsystem Member
•
Middle
Formula Manipal
•
Full-Time
Implemented a navigation-oriented perception pipeline combining object detection with camera geometry methods and feature matching for waypoint extraction. Trained a ResNet-based keypoint regression model for track positioning. Built a Gazebo-based robot simulation and implemented ROS publish-subscribe and service-oriented communication for triangulation.
Gazebo
ROS
ResNet
Senior AI/ML Engineer
Confidence: High LLM Engineer
Senior-level agent-infrastructure and applied ML engineer specializing in replay-safe agent execution and U-Net based medical image segmentation. The strongest proven skill is building robust agent runtime guarantees and orchestration (PostgresEventStore, idempotency, lease-fencing and FastAPI control surface in causality/src/causality/store.py and causality/src/causality/api.py). Public work lacks evidence of production-scale training infrastructure (distributed training, quantization), experiment tracking, and formal model lifecycle metrics and monitoring.
Model Architecture & Training
3/10
How well models are designed and trained
Model architecture and training evidenced by multiple TensorFlow/Keras notebooks implementing U-Net/V-UNet variants with pretrained backbones, custom losses and training loops, but no evidence of large-scale or distributed training, advanced optimization schedules, or productionized training pipelines.
Evidence
unet-fet/training_VUnet_fetal_head_reducelr.ipynb: build_Unet, model.compile, custom dice_coef and dice_coef_loss
unet-fet/Copy_of_VUnet_fetal_head_run_on_all.ipynb: build_Unet using EfficientNetB4 backbone and training loop
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Clear, hands-on data pipeline and preprocessing in notebooks: custom generators, augmentation, resizing, mask processing and ellipse-fitting for downstream measurement extraction.
Evidence
unet-fet/training_VUnet_fetal_head_reducelr.ipynb: Generator, train_Generator, image_Generator, mask_Generator
unet-fet/training_VUnet_fetal_head_reducelr.ipynb: fitEllipse, getbound, get_largest_component functions
Experimentation & Evaluation
3/10
How results are measured and tested
Experimentation and evaluation are present in notebooks (training histories, metric plots, Bland-Altman style analysis, saving best checkpoints) but there is no evidence of experiment-tracking (W&B/MLflow) or systematic A/B/ablation harnesses.
Evidence
unet-fet/training_VUnet_fetal_head_reducelr.ipynb: use of ModelCheckpoint, results.history plotting and metric aggregation
unet-fet/Copy_of_Unet_fetal_head_seg_new_runall2302.ipynb: histogram and statistical analysis of dice/jaccard values
MLOps & Deployment
5/10
How models are shipped to production
Strong production-oriented engineering for agent orchestration: a Postgres-backed append-only event ledger, idempotency, worker lease/fencing, schema migration hooks, FastAPI HTTP control surface and comprehensive integration tests indicate real MLOps / agent-infrastructure capability.
Evidence
causality/src/causality/store.py: PostgresEventStore with append, transition, claim_execution_with_lease, idempotency handling and append-only trigger creation
causality/src/causality/api.py: create_app, lifespan, readiness/live/health endpoints and transition/signal/resume handlers
causality/tests/integration/test_postgres_store.py and causality/tests/integration/test_api.py: integration tests exercising lifecycle and recovery behaviour
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to efficiency (use of pretrained frozen backbones, minibatched generators) but no evidence of measured GPU optimization, quantization, batching strategies for throughput, or profiling/benchmark numbers.
Evidence
unet-fet/Copy_of_VUnet_fetal_head_run_on_all.ipynb: freezing EfficientNet/VGG layers and using batch generators
unet-fet/training_VUnet_fetal_head_reducelr.ipynb: use of Conv2DTranspose and steps_per_epoch arithmetic
Research Depth & Innovation
4/10
Depth of research and new ideas
Design shows research-quality thinking in systems: replay-safe execution, idempotency semantics, lease fencing and append-only guarantees are non-trivial and demonstrate innovation in agent runtime reliability, though not necessarily novel ML algorithm research.
Evidence
causality/src/causality/store.py: append-only trigger creation, idempotency lookup, next_sequence management and _append_locked implementation
causality/src/causality/worker.py and tests: worker lease and recovery semantics (claim, renew, heartbeat) and thorough tests for race conditions
Verified artifacts
Expertise
AI Agents & Agentic Workflows• Senior
Computer Vision & Image Analysis• Middle
Technologies
Deep Learning
PostgreSQL
Redis
Weaviate
LangGraph
AutoGen
LangChain
Claude
OpenCV
Claude Code
Model Context Protocol
GitHub Actions
Computer Vision
AI Agents
Transfer Learning• since 2023
Azure
CI/CD
TensorFlow
Pandas
NumPy
Git
Docker
LLM• since 2025
RAG• since 2025
ResNet• since 2020
TF-Keras
HTTPX
Vector• since 2025
Hugging Face
GitHub
OCR
LLM Guardrails• since 2025
LangGraph• mentioned only
Recommendations
- Develop production-grade agent orchestration, recovery and observability features for LLM-based systems (lease renewal metrics, drift monitors and event-stream dashboards).
- Productize the medical imaging pipeline into a reproducible training/serving stack (data ingestion, unit tests for preprocessing, CI for notebooks, containerized model serving).
- Build experiment tracking and reproducibility (W&B/MLflow or structured run metadata) and add performance benchmarks (GPU utilization, throughput, memory) for model variants.
- Harden inference and deployment: add model serialization/versioning, quantization experiments, and lightweight APIs for on-prem/edge inference of segmentation models.
Middle Backend Developer
Confidence: High Distributed Systems
A backend engineer (senior) specializing in replay-safe, Postgres-backed execution primitives and event-sourcing for agent runtimes. The strongest proven skill is designing a Postgres append-only event store with lease/fencing, idempotent step claiming and transaction-scoped sequencing as shown in causality/src/causality/store.py and validated by causality/tests/integration/test_postgres_store.py. There is little public evidence of production authentication/authorization layers, extensive observability (metrics/tracing), or cloud deployment/infra automation in the provided human-authored code.
API Design
6/10
How well APIs are designed
API surface is well-structured with typed request models, explicit idempotency handling, proper HTTP status codes and a demo surface; lacks a documented versioning strategy or advanced API governance features.
Evidence
causality/src/causality/api.py: Pydantic request models (CreateExecutionRequest, TransitionRequest, SignalRequest) and endpoints using idempotency_key in transition
causality/tests/integration/test_api.py: end-to-end tests exercising transitions/signals/resume and expected HTTP statuses
Data Layer & Database
8/10
Working with databases
Strong data-layer design: async SQLAlchemy + asyncpg usage, explicit schema creation/migration support, append-only enforcement and transaction-scoped sequencing with careful locking and idempotency checks.
Evidence
causality/src/causality/store.py: PostgresEventStore.create_schema creates append-only trigger and alters projection columns; append/transition implement sequence allocation under row lock
causality/migrations/versions/0001_initial.py: migration skeleton evidencing a migration chain
causality/tests/integration/test_postgres_store.py: tests for idempotency, concurrent appends and transition projection updates
Scalability & Performance
7/10
Handling load and speed
Good concurrency and scalability primitives: worker lease/fencing, skip-locked row selection, idempotent step claiming and tests showing concurrent append behavior; lacks explicit cache/invalidations or documented rate-limiting strategies.
Evidence
causality/src/causality/store.py: claim_execution_with_lease uses with_for_update(skip_locked=True) and returns fencing token; claim_step uses pg_insert(...).on_conflict_do_nothing pattern
causality/tests/integration/test_postgres_store.py: test_concurrent_appends_get_unique_sequences validates concurrent sequence assignment
System Architecture
7/10
Overall system structure
Clear modular decomposition (API, execution boundary, event store, worker), deliberate contract boundaries (ExecutionContext) and a dashboard demo that exercises recovery semantics; not a large microservices mesh but focused, reasoned service design for an event-sourced runtime.
Evidence
causality/src/causality/execution.py: ExecutionContext encapsulates run_step, retries, failure recording
causality/src/causality/api.py + causality/src/causality/worker.py: separation of HTTP control surface and worker execution logic
Security & Auth
3/10
Protecting data and access
Basic boundary hygiene present (Pydantic models, use of SQLAlchemy to avoid raw string interpolation) but no evidence of authn/authz, secrets lifecycle, token revocation, or a dependency vulnerability audit in the code examined.
Evidence
causality/src/causality/api.py: Pydantic models used for request validation
causality/src/causality/store.py: SQLAlchemy usage (parameterized queries) reduces SQL-injection risk
Reliability & Observability
7/10
Stability and monitoring
Strong reliability patterns: idempotency, append-only guard triggers, lease renewal, retry-with-recorded-failure, and good test coverage for race/recovery cases; limited evidence of structured metrics/alerting or distributed tracing hooks.
Evidence
causality/src/causality/execution.py: run_step_with_retry and record_failure implement retry and failure recording
causality/src/causality/store.py: create_schema installs append-only trigger; renew_lease and claim_execution_with_lease implement lease semantics
causality/tests/integration/test_postgres_store.py: tests for lease renewal, expired-lease reclaim and recorded-work reuse
Expertise
Python• Middle
Microservices & API Architecture• Middle
Databases & Vector Storage• Middle
Industries
Education• Middle
Technologies
Rest API
SQLAlchemy
FastAPI
Pydantic
Recommendations
- Develop distributed agent runtimes and reliable orchestration components that require idempotency and recovery (workers, leases, event stores).
- Design and implement back-end services that need strong consistency guarantees and recovery semantics (financial workflows, payment orchestration, long-running jobs).
- Build developer-facing tooling for LLM/agent systems that require cost/feasibility estimation and replay-safe execution boundaries.
- Extend observability and operational readiness: add structured metrics, tracing and documented deploy/migration procedures to harden production readiness.
Middle DevOps Engineer
Confidence: High Platform SRE
Platform-focused engineer building replay-safe, Postgres-backed execution and worker systems with strong correctness and recovery guarantees. The strongest proven skill is designing a replay-safe event store and worker lease/fencing machinery, as implemented in causality/src/causality/store.py and causality/src/causality/execution.py with accompanying integration tests. There is little public evidence of IaC at scale, Kubernetes or cloud autoscaling patterns, or advanced CI/CD pipeline engineering in the analyzed human-authored files.
CI/CD Pipelines
2/10
Automated build and deploy
Minimal CI/CD evidence: repository contains Dockerfiles and docker-compose with healthchecks but no full pipeline engineering (no reusable workflows, artifact signing, or deploy gates).
Evidence
causality/Dockerfile: multi-stage build and runtime image
causality/docker-compose.yml: service healthcheck and postgres service
Infrastructure as Code
1/10
Managing servers with code
Very limited IaC: there are container and migration assets but no Terraform/Pulumi modules, no remote state/locking, and no environment-separated infrastructure modules or state migrations in code.
Evidence
causality/docker-compose.yml: local postgres service and volume
causality/migrations/versions/0001_initial.py: alembic migration present (schema migration artifacts)
Containerization & Orchestration
4/10
Working with containers
Solid containerization practices for a backend service: multi-stage image, non-root runtime user, EXPOSE and healthcheck; no Kubernetes manifests or advanced orchestration tuning present.
Evidence
causality/Dockerfile: builder/runtime stages, non-root user creation, HEALTHCHECK
causality/docker-compose.yml: healthcheck and service dependency on postgres
Observability & Monitoring
4/10
Watching system health
Observability basics implemented: service exposes liveness/readiness endpoints and readiness checks the database, enabling external health monitoring and graceful readiness signaling; no SLO/SLA or advanced alerting-as-code found.
Evidence
causality/src/causality/api.py: /health, /health/live and /health/ready endpoints with store.ping check
causality/tests/integration/test_api.py: tests exercising readiness and liveness behavior
Reliability & Incident Response
7/10
Keeping systems up
Strong reliability and recovery design: append-only Postgres-backed event store, idempotency keys, step claiming with lease/fencing, worker lease renewal and recovery tests demonstrate deliberate handling of concurrency, replay and fault scenarios.
Evidence
causality/src/causality/store.py: PostgresEventStore with append/transition/claim_execution_with_lease/renew_lease and append-only trigger setup
causality/src/causality/execution.py: ExecutionContext run_step, run_step_with_retry, record_failure with idempotency and step claim/release
causality/tests/integration/test_postgres_store.py: tests for idempotency, lease renewal, recovery reuse and concurrent appends
Cloud & Cost Optimization
1/10
Smart use of the cloud
Minimal cloud or cost-optimization artifacts: Postgres and Docker usage are present but there is no evidence of autoscaling, spot strategies, privilege minimization across cloud IAM, or cost-measurement tooling.
Evidence
causality/docker-compose.yml: local Postgres service
causality/src/causality/__main__.py: uvicorn entrypoint for self-hosted runtime
Expertise
Platform Engineering & IDP• Middle
Site Reliability Engineering• Middle
Technologies
Containers
Python• since 2024 • Senior
Docker Compose
Asyncio
Uvicorn
Alembic
Recommendations
- Design and implement durable orchestration or workflow services that require strict replay and idempotency guarantees, such as long-running business processes or agent orchestration.
- Develop fault-tolerant worker fleets and leader-election/lease systems that integrate with cloud-managed Postgres and runbooks for operational run/repair procedures.
- Hardening and productionization of deployment pipelines: add reproducible CI flows, artifact signing, and staged deploy gates (canary/blue-green) for production rollout.
- Add observability-as-code: SLI/SLO definitions, Prometheus metrics and alerting rules for lease expirations, replay rates and tail-risk, plus automated smoke tests for recovery scenarios.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: