Open to remote AI / ML roles, contract or full time

I build machine learning
from the GPU kernel to production.

I'm Laela Zorana, an ML systems and performance engineer. I make models fast enough and small enough to actually run, from the CUDA graphs and quantization underneath to the served API on top, and I report the measured number for the things that worked and the things that didn't.

Remote · Burr Ridge, IL

View work GitHub LinkedIn

5.9x: CUDA-graph win on a VLA sampler (T4)
595/s: inference req/s, p50 13.35 ms (offline stub)
97.6%: citation accuracy, grounded RAG, 53-question offline eval
80%: tickets deflected (seeded 20-ticket eval)

Real products, with the numbers to prove them.

Eight end-to-end builds, each framed as problem → solution → result. Every card links the source, and most have a live demo on Hugging Face. Click any card.

embodied-efficiency

GPU · Systems

Kernels, quantization, and a runtime safety layer for vision-language-action models, so they run inside a real latency budget. Problem: a VLA can do the task but runs at 3 to 5 Hz, and a robot arm needs 50 to 100 Hz. Solution: capture the flow-matching sampler in a CUDA graph, then measure every other lever instead of assuming. Result: one big win, one honest negative, both reported the same way.

Standout metric

5.9x CUDA-graph speedup, 4.82 to 0.82 ms/step on T4

And the negative result: weight-only low-bit bought no batch-1 latency across four experiments, with torchao/Marlin int4 running 1.2 to 1.6x slower than bf16 on an L4.

CUDA graphs PyTorch Quantization Triton

Code Live demo

ParaPilot

RAG

An Illinois divorce "legal GPS", a grounded, cited RAG assistant that answers procedural questions with source links instead of guesses. Problem: legal chatbots invent law. Solution: retrieval that refuses to answer without a citation. Result: 92.7% answer correctness with 97.6% citation accuracy on the 53-question offline eval.

Standout metric

92.7% answer correctness · 97.6% citation accuracy, offline eval, 53 gold questions

Measured on real generations over 53 curated Illinois-divorce questions. The ungrounded baseline in the repo is a deterministic simulation, so its 100% is by construction and not the number that matters.

Python FastAPI RAG htmx

Code Live demo

SupportCopilot

RAG + Ops

E-commerce support automation that answers customers and applies policy-correct refunds from the knowledge base. Problem: support headcount can't scale. Solution: RAG grounded in store policy with a refund-decision engine. Result: most tickets never reach a human.

Standout metric

80% ticket deflection · about $7.8k/mo ROI

Measured on a seeded 20-ticket eval set (16 of 20 auto-resolved), with the dollar figure projected out to 3,000 tickets a month. The public demo runs a deterministic stub unless you add an API key.

Python RAG FastAPI Dashboard

Code Live demo

InterviewCoach

Full-stack

Paste a job description, get tailored interview questions, then have your answers rubric-scored with feedback. Problem: generic prep doesn't match the role. Solution: JD → questions → graded answers in one flow. Result: a full-stack app you can run offline in one click.

Standout metric

Full-stack · one-click offline demo

Python FastAPI LLM Rubric eval

Code Live demo

LLM Security Scanner

Security

An LLM red-team harness plus governance mapped to NIST AI RMF and ISO 42001. Problem: teams deploy LLMs with no safety evidence. Solution: automated injection / jailbreak / PII probes. Result: a severity-scored report you can hand to compliance.

Standout metric

Injection / jailbreak / PII probes, severity-scored

Python Red-team NIST AI RMF ISO 42001

Code Demo offline, run it locally

Solidity Audit AI

Web3 · Security

A smart-contract auditor with 10 SWC detectors and a paste-a-contract web UI. Problem: contract bugs are expensive and noisy to find. Solution: targeted detectors with a clean report. Result: catches real issues with zero false positives on safe fixtures.

Standout metric

0 false positives on safe fixtures

Python Solidity SWC Web UI

Code Live demo

DistilBERT Emotion API

MLOps

A production inference service for emotion classification, instrumented with Prometheus + Grafana. Problem: a notebook model isn't a service. Solution: a real API with monitoring, micro-batching, and a load test anyone can rerun. Result: throughput scales about 5x from serial to 8 concurrent requests, with zero errors.

Standout metric

595 req/s · p50 13.35 ms at 8 concurrent · Prometheus/Grafana

Measured against the offline stub on a single uvicorn worker, so it's the service shape and the batching win being benchmarked, not the model. The real model adds inference cost on top.

FastAPI Transformers Docker Prometheus

Code Live demo

CommercePipeline

Data Eng

A DuckDB analytics pipeline: raw → marts → data-quality gates → dashboard. Problem: dashboards lie when the data is bad. Solution: tested transforms with quality gates that fail the build. Result: every metric is gated before it goes live.

Standout metric

100k+ rows · 16/16 quality gates passing

DuckDB Python SQL Streamlit

Code Live demo

About

A model too slow to run isn't a model you can deploy.

Most of my work now sits at the point where a model meets a clock and a power budget. I capture samplers in CUDA graphs, measure quantization instead of assuming it helps, and put the whole search behind a compiler you hand a budget to. When a lever doesn't pay off I say so and show the four experiments.

The evaluation habit came first, and it's still underneath all of it. My career ran through systems where a mistake is expensive, in banking, risk, and large operations, and that taught me to prove a thing works before it goes to production, not after. So the products here come with a held-out test, an eval harness, or a benchmark you can rerun, and the caveats stay attached to the numbers.

I'm comfortable across the whole stack, from the kernels and latency budgets underneath to training and fine-tuning models, wiring them into clean FastAPI services and front-ends, and deploying with Docker, CI, and monitoring. I care about the unglamorous parts: tests, tail latency, failure cases, and a demo a recruiter can run in under a minute.

At a glance

Role: ML systems and performance engineer
Builds: CUDA-graph samplers, quantization, inference services, RAG and LLM apps, eval harnesses
Proves: Latency benchmarks on real GPUs, held-out tests, eval harnesses, data-quality gates
Stack: Python PyTorch CUDA Triton Transformers FastAPI RAG Docker DuckDB Prometheus
Cert: AI Agents & Agentic AI Architecture (Python), Vanderbilt 2025
Based: Remote · Burr Ridge, IL

Hugging Face Kaggle

More work

Open-source repos & experiments.

Evaluation and rater tooling. It's the smaller supporting work, and it's where the habit of grading a model before trusting it came from.

ai-agent-scenario-qc

Rubric scoring + defect log for agent training scenarios

rlhf-pairwise-rater

Preference rating with Cohen's kappa agreement checks

content-policy-rater

Policy-based content labeling and rater tooling

See all repositories on GitHub

Contact

Let's build something that works.

I'm open to remote ML systems and performance work, contract or full time. The fastest way to know if I'm a fit is to open one of the products above, then email me at zoranalaela9@gmail.com.

Email me Connect on LinkedIn View GitHub Hugging Face

I build machine learning from the GPU kernel to production.

Real products, with the numbers to prove them.

embodied-efficiency

ParaPilot

SupportCopilot

InterviewCoach

LLM Security Scanner

Solidity Audit AI

DistilBERT Emotion API

CommercePipeline

A model too slow to run isn't a model you can deploy.

At a glance

Open-source repos & experiments.

Let's build something that works.

I build machine learning
from the GPU kernel to production.