Case study · Video-analytics platform · MYTEAM.ai

Avertix

A platform that turns camera streams into alerts an operator can review, acknowledge and route, with one inference worker packaged for the cloud and for Jetson devices on site.

Role
Hands-on technical lead
Context
MYTEAM.ai; collaborative product and research
Built with
Python, FastAPI, PostgreSQL, React, TypeScript, Docker, Kubernetes, ArgoCD
Status
Company platform; GPU demonstration environment operated; Jetson path packaged
Layers
Interfaces, systems, models, delivery
Fig. 1 · From camera to operator
  • Led by me
  • Outside the platform, or collaborative
  1. Camera sourcesAdded, configured and diagnosed from the consoleOutside the platform
  2. Inference workerOne worker, packaged for cloud GPUs and for Jetson; deployment mode set per siteLed by me
  3. Control planeFastAPI on PostgreSQL; immutable, versioned eventsLed by me
  4. Alert projectionsWritten in the same transaction; acknowledge lifecycleLed by me
  5. Avertix ControlReact and TypeScript console and alert destinationsLed by me

Feeding the worker

  1. Video modelsVideoMAE and I3D branches developed in collaborative researchCollaborative research
  2. Model start-upLazy, thread-safe loading and an asynchronous warm-up the interface can showBuilt by me
Context

Two kinds of hard problem

Video analytics has two kinds of hard problem. One is the model: deciding whether a few seconds of footage contain the event that matters. The other is everything around it: where video is allowed to be processed, how an alert is stored and acknowledged, how an operator sets up cameras and sees what went wrong, and how a new version reaches a GPU node or a small device on site without breaking the old one.

The models came out of collaborative research that I also worked on (see the video-models overview). I lead the platform around them hands-on, writing and reviewing its code with the team.

What I built

Six parts of the platform

  1. 01 · Systems

    An event store behind every alert

    A FastAPI service on PostgreSQL records detections as immutable, versioned events. Alerts are projections written in the same transaction, so the alert view and the event history cannot drift apart, and operators work through alerts with an acknowledge lifecycle.

    I lead the integration path from alerts to external applications: a provider-neutral adapter interface, signed webhooks, and a durable outbox with retries, dead-letter handling and replay. Delivery is at least once, with idempotency keys for duplicates. Adapters must pass conformance checks.

  2. 02 · Models

    One worker, two targets

    The inference worker is the same code, packaged for a cloud GPU node and for an NVIDIA Jetson. Deployment modes (sequential, full-cloud and full-edge) are an explicit contract, so a site’s constraints on where video may be processed decide where inference runs, without forking the code.

    I lead a streaming worker with one capture thread per camera and downscaled frames in a bounded buffer that model pipelines share read-only. Sampling and stride control cadence; Prometheus exposes p95 inference latency and temporal coverage.

  3. 03 · Interfaces

    Avertix Control

    A React and TypeScript console for setting up cameras, choosing where alerts go and diagnosing sources, built on TanStack Query with zod-validated data. Vitest covers the components; Playwright runs end-to-end journeys with axe accessibility checks.

    API calls go through a shared client that checks every response against a zod schema, with a live-contract test for the API boundary.

  4. 04 · Delivery

    Gates on every merge

    CI runs type checking with mypy, import-layer contracts and the test suite. Separate workflows scan for leaked secrets with gitleaks and vulnerable dependencies with OSV. A merge gate admits a change only after independent review and passing checks on the exact commit.

  5. 05 · Delivery

    Paths to the cloud and the edge

    I configured Kubernetes manifests reconciled by ArgoCD; canary releases with Argo Rollouts that step from 25 to 50 to 100 percent; a GPU node pool that scales to zero when idle; and pull-based updates for Jetson devices through Rancher Fleet.

    I built an arm64 Jetson worker image with pinned CUDA-compatible PyTorch dependencies and configured emulated smoke checks in CI. These checks cover the image build; inference on the device is still to be benchmarked.

  6. 06 · Models

    A first inference that doesn’t look frozen

    In the demonstration codebase I containerized the back end with GPU and CPU profiles, added an in-process inference mode combining the VideoMAE and I3D models, made model loading lazy and thread-safe, and added an asynchronous warm-up with a status indicator in the interface.

Models in the product

From research model to checked worker

  1. 01 · Models

    A research ensemble, packaged and checked

    I packaged the VideoMAE-MIL and I3D ensemble into the platform worker with checksummed model artifacts. I checked CUDA/CPU score parity on a fixed fixture and benchmarked warm inference on an RTX 4060 laptop GPU. It sustained the tested cadence of non-overlapping two-second windows; the CPU did not.

  2. 02 · Models

    Conversion and quantization, with the trade-off

    I exported X3D-M to ONNX and tested static INT8 quantization with ONNX Runtime on a T4 GPU. The INT8 file was 3.5 times smaller, with slightly lower accuracy and no per-video speed-up. I also built TensorRT engines in FP32, FP16 and INT8. These were experiments; the deployed worker still uses PyTorch.

Delivery

From a reviewed change to a running node

Fig. 2 · Release path
  • Led by me
  1. ChangeIssue-scoped branch and independent review
  2. Merge gateTypes, import layers, tests, secret and dependency scans, all green on the exact commit
  3. ArgoCDDeclared state reconciled into the cluster
  4. CanaryTraffic stepped from 25 to 50 to 100 percent
  5. RunConfigured: GPU pool that scales to zero; Jetson updates pulled through Fleet
Leading the work

How work gets merged

I set the platform’s delivery protocol: issue-scoped branches, independent review, and merges gated on passing checks for the exact commit. It keeps changes small enough to review and makes the main branch something a deployment can trust.

On the demonstration codebase I was lead and sole reviewer for two interns’ feature pull requests. The deployment modes follow from what customers allow to leave their sites, and they live in the code as a contract rather than as a convention.

Status and scope

What this is, precisely

Status. Avertix is a company platform. I operated a GPU demonstration environment for it. The Jetson work covers the worker image and its deployment configuration; inference on the device is still to be benchmarked, and I don’t quote latency or availability figures.

Scope. Avertix as a product is a team effort, and its video models came from collaborative research. I lead the platform code (control plane, worker, console, CI and infrastructure) hands-on, through implementation and review.