Rob Newman

Typed multi-step request workflows

Ten distinct request types (new line, port-in, SIM replacement, hardware change, hotspot, tablet, smartwatch, change of responsibility, and more), each implemented as its own React form component with client-side validation and a shared submission pipeline feeding a central request store.

Request lifecycle state machine

Every submission is assigned a unique request ID and tracked through Pending, In Progress, Completed, and Rejected states, with status surfaced to both the requester's dashboard and the admin queue from a single source of truth.

Role-based portals on shared infrastructure

Separate employee and admin route groups under the Next.js App Router share a common layout system, sidebar navigation, and component library, while rendering role-specific views for requests, billing, users, and settings.

Per-line billing engine

A billing module computes each employee's monthly cost from a centralized pricing model, itemizing base plans, add-ons, and employee-benefit lines per device with payroll-deduction summaries. Currently mock-backed, with live carrier billing data as the next integration milestone.

T-Mobile API integration layer

Planned direct integration with T-Mobile's business APIs to pull per-line call logs and usage data, enable user self-management of plans and add-ons without IT involvement, and process payments through an integrated payment system rather than payroll deduction alone.

Server-side notification layer

API route handlers deliver transactional email (Nodemailer with reusable HTML templates) and SMS status alerts on request state changes, plus SIM inventory tracking with configurable low-stock thresholds surfaced on the admin overview.

A native Slate chat panel bridges to the Claude Code CLI over a custom streaming-JSON stdio protocol, closing the loop end-to-end: a natural-language request in the editor spawns an agent that calls back into the editor's own tools, creates real assets, and supports one-click rollback of everything it did. The system was verified live: an AI agent built and opened working Blueprint assets from a single chat message.

MCP server implemented from scratch in C++ inside the UE editor

JSON-RPC 2.0 over Streamable HTTP per the 2025-03-26 spec, with resources, auth tokens, CORS, rate limiting, request-size limits, and input sanitization.

A 566-tool agent toolset with zero-registration architecture

Tools self-describe with JSON Schema and are auto-discovered via UClass reflection (TObjectIterator), organized across 25+ subsystems from Blueprint graph authoring to multiplayer replication.

Reverse-engineered bridge to the Claude Code CLI's streaming-JSON protocol

A stdio process bridge with newline-delimited frame parsing, session resume across turns, and full tool-call round-tripping, so the agent's tool calls execute inside the live editor.

Transactional plan executor with diff capture and rollback

Every file/asset mutation is recorded and reversible, wrapped in editor transactions for one-click undo, with an audit log behind it.

Defense-in-depth security hardening

A canonical path sandbox (closing the FPaths::IsRelative cross-platform trap), protected-rails deny-lists ahead of every tool call, and Python injection-pattern screening, all covered by dedicated attack-vector tests.

Local image-to-3D pipeline

A self-hosted Hunyuan3D-2 inference server (PyTorch/CUDA, VRAM-adaptive with automatic CPU offload) feeding generated GLB/FBX meshes through Interchange import with automatic LOD chain generation.

Vision-to-scene: a playable Unreal level from a single reference image

Object detection with bounding boxes, three-tier mesh resolution (asset registry, then generative 3D, then fallback), and a PBR material library scanner that auto-wires Quixel/Poliigon texture sets into complete material graphs, including packed ORM channel detection.

Retrieval-augmented project memory

Vector store with neural embeddings, semantic search, tiered memory, dependency graphs, and a context assembler that keeps the agent grounded in the actual project state across sessions.

Low-level infrastructure written by hand where dependencies weren't worth it

A clean-room PKZIP reader/writer (EOCD/central-directory parsing, CRC-32) and SHA-256 content integrity verification for the content-pack pipeline.

Shipped with real engineering discipline

~357 automation tests across 36 suites, genre-recipe acceptance tests (64 game presets), external-service smoke tests, GitHub Actions CI on a self-hosted UE 5.7 runner with strict-includes builds, and lint-enforced conventions.

DeepBlender is not a chatbot bolted onto Blender. It is a tool-using agent architecture: the LLM never emits freeform code into the user's scene. Instead it plans against a typed registry of validated tools, previews every plan with per-step risk levels, executes non-destructively with undo-safe checkpoints, and validates the result against production Unreal Engine standards before export. The system is designed so a complete beginner can type "create a low-poly dragon, game-ready for Unreal" and get a rigged, UV-unwrapped, LOD'd, collision-ready FBX, while a technical artist can drive the same pipeline for batch automation.

~390 Python modules across the addon and backend, a 130-case headless unit test suite, and a multi-process architecture that keeps heavy ML dependencies out of Blender's embedded interpreter.

Tool-using agent over code generation

Every AI action routes through a versioned tool registry where each tool declares its required Blender mode, object types, and side effects. This gives the planner machine-checkable preconditions, enables per-step risk classification, and eliminates the entire class of "LLM wrote bad bpy code" failures.

Pluggable LLM backend abstraction

A common interface with interchangeable Anthropic API, GitHub Models, and deterministic mock backends; OAuth 2.0 device flow so no secrets are embedded.

Deterministic prompt-assembly pipeline

System prompt, project memory, live scene snapshot, RAG context, few-shot examples, and history composed as independently testable stages under an explicit token-budget manager.

Custom RAG pipeline

Purpose-built chunker, embedder, vector store, query expansion, and caching, ingesting Blender API docs, workflow playbooks, and Epic's Lyra UE5 sample, grounding the model in Blender 5.1 / Python 3.13 reality instead of stale training data.

Scene-aware planning with a repair loop

Structured scene snapshots diffed before/after execution; failures feed a self-healing loop (diagnose, categorize, fix, re-execute) with crash recovery and plan resumption.

Multi-step planner with human-in-the-loop approval

Intent classification and task decomposition produce plans the user can approve, modify, reorder, or skip per step, non-destructive and undo-safe throughout.

Production UE pipeline encoded as validators

Asset health scoring plus enforced SM_/UCX_ naming, sockets, LOD0-3, lightmap UVs, texel density, and per-profile FBX presets (hero, environment, foliage, Nanite). Validation is part of creation, not an afterthought.

Local ML inference sidecar

Auto-spawned FastAPI service in its own process/venv, async job queue with Server-Sent Events progress, and a VRAM state machine sequencing Hunyuan3D-2 / SDXL / ControlNet within a 12 GB GPU budget.

GPU-drawn viewport overlays

Real-time texel-density, polygon-density, normals, and validation overlays written against Blender 5.1's gpu module post-BGL-removal, with a 5.1 / Python 3.13 compatibility layer.

Multi-surface delivery

One backend powering three front ends: the in-Blender sidebar, a VS Code @blender chat participant, and a GitHub Copilot Extension server, kept protocol-compatible via shared schemas.

True multi-tenant SaaS architecture

Subdomain-per-tenant isolation on a unified schema, with a separate operator control plane so platform administration never touches customer traffic.

~30 domain-driven backend services in a TypeScript monorepo

Incidents, changes, assets, on-call, compliance, procurement, projects, and more, cleanly separated behind a single API gateway serving four frontend applications.

Agentic AI throughout the product

An AI assistant that triages, categorizes, and acts on tickets; a generative support chatbot; and natural-language analytics that turn plain-English questions into live dashboards. All engineered with graceful degradation, so the platform stays fully functional even if AI services go down.

Sandboxed custom script execution

Customers write their own automation scripts inside the workflow engine, executed in an isolated sandbox. Arbitrary user code, run safely. Most SaaS teams avoid that feature entirely.

Proven performance under load

1,700 requests per second with a 23ms p99 and zero errors, powered by a Redis caching layer with automatic in-memory fallback.

Disaster recovery that's been rehearsed, not just written

Scripted backup and restore with a full restore drill executed and verified before launch.

Security-first by design

Fail-fast secret validation (production refuses to boot on weak credentials), enforced operator MFA, SSO/IdP integration, and JWT auth with refresh-token rotation.

Fully internationalized

Every page and component localized in English, Spanish, French, and German, built into the architecture rather than bolted on.

Deep quality engineering

A 575-test end-to-end smoke suite plus a dedicated backend unit-test layer, covering the full ITIL feature surface on every release.

Complete operational maturity

Containerized dev and production environments, a launch runbook, production-readiness audit, embeddable live-chat widget, and per-tenant billing portal.

A single static Go binary agent with zero third-party dependencies

Standard library only, cross-compiled to five OS and architecture targets. Nothing to install on the endpoint, no runtime to maintain, and no dependency vulnerabilities inherited onto managed machines.

Content filtering enforced on the device by a purpose-built UDP DNS server

The agent parses queries in-process, answers blocked domains with genuine NXDOMAIN responses and forwards the rest upstream, so policy follows the device onto any network, home or corporate. Competitors route this to partners; OhKube owns the enforcement path.

Vulnerabilities ranked the way defenders actually triage them

Risk ordering runs CISA Known-Exploited first, then severity band, then CVSS, then EPSS exploit probability, drawing live from NVD, the CISA KEV catalogue and FIRST. Sorting by CVSS alone is the naive approach; this surfaces what is genuinely being exploited in the wild.

Threat detection matches cryptographic hashes, not just process names

The agent computes SHA-256 of every running executable, cached by resolved path so long-lived processes aren't rehashed on each cycle. Name matching catches renamed tooling; hash matching catches the binary itself, whatever it's called.

Short-lived processes don't slip through

A continuous watcher diffs the process table and buffers start events between reporting cycles, so a credential dumper that runs for two seconds between check-ins is still caught. That's the exact failure mode snapshot-based telemetry misses.

Command delivery uses SELECT … FOR UPDATE SKIP LOCKED

Thousands of agents can poll concurrently, each receiving distinct work with no double-delivery and no lock contention. It's the correct Postgres work-queue pattern, and rarely the first one people reach for.

Apple's Declarative Device Management implemented to spec

Content-hash-derived synchronisation tokens, correct JSON-over-check-in transport, and scope enforcement that refuses declarations a device isn't entitled to. The protocol layer also handles Apple's NotNow response correctly, requeueing with backoff instead of treating it as a failure.

The migration runner refuses to run against rewritten history

Every applied migration's SHA-256 is recorded, and the runner aborts if a previously-applied file has changed, and each migration runs in its own transaction with rollback on failure. This is the safeguard most teams add only after being burned once.

Tenant isolation enforced by contradiction, not trust

Services derive tenant identity from the verified token claim and reject any request whose supplied tenant header disagrees with it, treating a mismatch as an attack signal rather than silently preferring one source over the other.

Windows management is deliberately agent-based rather than native OMA-DM

Microsoft owns the Windows enrolment funnel through Entra and Autopilot; competing there buys years of work for parity at best. NinjaOne, a Gartner Magic Quadrant Leader managing over 14 million endpoints, made the same call, and so did JumpCloud. Part of the job is knowing which battles not to fight.

Drop-in adoption, real enforcement

One base_url change, no SDK rewrite. But unlike a passive proxy, the gateway blocks, redacts, and refuses at request time: DLP violations return 400, exceeded budgets return 402, policy denials never reach the provider.

Data-loss prevention that reads the whole request

Every string in the request body is walked, not just message content, so a credential hidden in a tool description, a tool_call argument, a nested tool result, or a metadata field is caught. Most scanners check the obvious fields and quietly miss the rest.

Streamed responses are enforced, not just reported

A sliding-window guard holds back output, scans it, and redacts before release. A release never splits a detection and nothing is ever released unscanned. Since virtually every production client streams, scanning after delivery means effectively no response-side coverage at all.

A hash-chained audit log that can prove it wasn't edited

Every administrative action commits the hash of its predecessor, append-only is enforced by a database trigger, and the chain is verified by recomputation with a live integrity banner in the UI. Deleting, reordering, or forging a record all fail the check.

One-click compliance evidence packs

Fourteen controls across the EU AI Act, NIST AI RMF, ISO/IEC 42001 and the OWASP LLM Top 10, generated from live platform data, each marked evidenced, partial, or not covered with the reason. It names its own gaps, because a pack that quietly omits them fails the external audit it was meant to pass.

A policy engine where the strictest rule always wins

Rules match on model, provider, endpoint, team, application, key scope, detector category, severity, or whether the request streams. The most restrictive matched effect wins regardless of order, so a later policy can never accidentally relax an earlier block. A policy that fails to parse is reported, never silently ignored.

Budgets that actually stop spend

Scoped to the organization, a team, an application, or a single key, enforced at the gateway with HTTP 402. Spend is summed from genuinely metered requests, and a scheduled checker reports a breach even when the offending team goes quiet, which is exactly the case a traffic-triggered alert misses.

Cost attributed to the team that spent it

Every request carries a team, application, environment, and virtual key, so "what does AI cost us?" gets a per-team, per-model, per-app answer with chargeback-grade attribution instead of one flat invoice from each vendor.

Least-privilege access, including for machines

Six roles enforced on every API route, plus scoped programmatic tokens whose permissions are the intersection of their scopes and their owner's current role, so a token can never exceed its owner, dies when they leave, and cannot mint another token.

Built so the evidence survives failure

Metering records are fsynced to disk before the response returns and drained in the background, so a database outage loses nothing. Recoverability is rehearsed by a command that restores a backup and re-verifies the audit chain, instead of assuming it would work.

Built the site as a prerendered SPA

30 routes driven through headless Chrome at build time, so search engines and AI answer engines get fully-rendered HTML while visitors get client-side routing after first paint.

Engineered the content architecture around typed data modules

Services, FAQs, county pages, articles, team and sale listings each live in a validated schema, so publishing is a data edit rather than a template change, and malformed content fails the build instead of the page.

Layered structured data across the whole surface

ProfessionalService, FAQPage, Service, BlogPosting, Event and BreadcrumbList schema, plus an llms.txt and a robots.txt that explicitly welcomes GPTBot, ClaudeBot and PerplexityBot, so the business is citable by AI search as well as rankable in Google.

Built a serverless mail backend, then hardened it

Origin checks, payload caps, per-field limits, a honeypot, a submission-time trap and a sliding-window rate limiter, closing a CRLF header-injection hole that would have let arbitrary SMTP headers into outbound mail.

Shipped a Content Security Policy that the test suite enforces

The end-to-end harness serves the exact production header set and fails on any violation, so a policy that would break the live site can't reach main.

Stood up a test suite from zero

248 unit and component tests plus 58 real-Chrome checks, covering the API contract, every page rendering in the real layout, form state machines, and things jsdom cannot see: horizontal overflow, focus rings, sticky headers and CSP behaviour.

The harness caught what review missed

Five defects that had passed review, including a focus trap filtering on offsetParent (always null under position: fixed, so it would have trapped nothing in a real browser) and a noindex page that was fully indexable because a static meta tag outranked the one React Helmet was managing.

Optimized the dependency surface from 23 vulnerabilities to 2

Upgrading React Router and Vite across three major versions, splitting vendor chunks so content changes don't invalidate the cache, and removing a critical-severity library along with the dead components that were its only consumers.

Tuned responsive behaviour and accessibility

Traced horizontal overflow at every viewport (50px mobile, 99px desktop) to scroll-triggered animations and an unshrinkable header flex item, and added skip links, visible focus states, reduced-motion support and full keyboard handling on every overlay.

Two-phase credit reservation over an append-only ledger

Balance is derived from SUM(transactions) − SUM(held reservations), never a mutable column. Submission opens a HELD reservation inside the same transaction as the job row; the worker transitions it to FINALIZED with a guarded updateMany count check so the debit lands exactly once, and any failure path transitions it to RELEASED, so a failed generation simply cannot charge the user. Insufficient balance returns HTTP 402 before anything is enqueued.

Idempotent job submission

A unique idempotencyKey collapses duplicate submits to a single job and a single charge, with a cross-user key-collision guard; the BullMQ jobId is pinned to the job's primary key so queue-level redelivery is a no-op, and the worker short-circuits on any non-QUEUED status.

Deterministic NL parser with no LLM in the critical path

Free text ("2 inch lift, 35s muddies, bull bar and a snorkel") resolves against a database-driven taxonomy with per-locale synonym sets. Candidate phrases are matched longest-first with lookaround boundaries so "bull bar" never degrades to the generic "bar", regex extractors attach typed units (inches, tyre diameter), taxonomy conflictsWith edges are surfaced as conflicts rather than silently resolved, and ambiguous or unmatched input is returned to the user instead of guessed at. Fully explainable and unit-tested in isolation.

Versioned contract boundary

All three input modes (text, voice, structured picker) normalize to a single Zod-validated BuildSpecV1 carrying schemaVersion; the parser dispatches on version and rejects unversioned blobs by name. The prompt engine consumes only this contract, never raw user text, and every spec is re-validated against the live taxonomy on write, including provenance flags that cannot be dropped.

Hardened upload pipeline

The API never proxies image bytes: clients receive short-TTL pre-signed PUT URLs and upload directly to object storage. On completion the server validates by decoding rather than trusting content-type, enforces a decompression-bomb pixel ceiling, normalizes EXIF orientation, and re-encodes to strip all metadata including GPS, while keeping the untouched original under a separate immutable key.

Default-deny authorization with enumeration-safe scoping

A global guard derives identity solely from a provider-verified token, never from request fields, and rejects non-active accounts. Every query is owner-scoped at the database level, and cross-tenant access returns 404 rather than 403 so resource existence never leaks. Fastify helmet, rate limiting, a 1MB body cap, and an exception filter that returns a correlation errorRef while logging internals privately.

Immutable revision tree

Each completed generation writes a BuildRevision with a parentRevisionId and monotonic per-branch revision number, snapshotting the exact spec and schema version used. Builds are branchable and comparable, and history is never rewritten. Provider calls are recorded with latency and cost in integer minor units.

Modelled an entire enterprise product from the domain up

Fourteen components with their real vocabulary and relationships: EPV, safes, platforms, PVWA, CPM, PSM, PSMP, PTA, AAM with both provider models, and cloud secrets management. Each is a working surface backed by a relational schema with enforced foreign keys, not a static page describing what the component would do.

Built all three consumer models, not just the human one

Most PAM material stops at the person using a portal. I also modelled applications retrieving credentials at runtime through a credential provider, and cloud workloads authenticating with identity their platform already vouches for: a Kubernetes service-account token, an AWS IAM role, a signed OIDC token from a CI pipeline.

Designed state that genuinely couples

Risk scores, compliance status, rotation state, grant expiry and lease validity are all derived on read rather than stored. Approving a request, rotating a credential or revoking a lease immediately changes the dashboard, the account page, the audit trail and the risk engine, because none of them hold a stale copy of anything.

Implemented dynamic secrets with real expiry

Cloud secrets are minted per request with a time to live and expire on their own, so there is nothing stored to steal and no rotation to schedule. Leases count down live and can be revoked, which makes the containment story concrete: you invalidate what was issued rather than change a password that does not exist.

Wrote an explainable risk engine and a named detection catalogue

Every risk point carries the sentence that justifies it, so a score can always be decomposed rather than trusted. Ten threat-analytics detections (credential theft, PSM bypass, golden ticket, over-pass-the-hash, unmanaged accounts and others) are modelled as data with the signal that raises each one and the response it calls for.

Enforced role-based access control in the API, not the interface

Ten roles across a permission model that the server checks on every request. Switching identity genuinely changes what the application will do, so an auditor attempting a credential retrieval is refused by the API with a reason, not merely shown a disabled button.

Built a teaching layer that grades against real application state

Thirteen click-by-click walkthroughs with 57 interview questions, plus eight graded labs verified against the audit events, rotation jobs and safes you actually produce. Only activity after a lab is opened counts, so the seeded history cannot pre-complete anything.

Built a verification harness that found real defects

Eight automated suites and roughly 300 assertions covering the API, every route across three roles and two viewports, end-to-end workflows, and text encoding. It caught genuine bugs, including two of my own test suites that were passing while testing nothing, which is exactly the failure a harness exists to prevent.

Diagnosed and fixed a 14× query amplification

Profiling showed a single dashboard issuing 248 database queries, because each mapper ran subqueries per row: free against an embedded database and ruinous against a networked one. Consolidating them into aggregates brought it to 18, which is the difference between a five-second page and a fast one once each query crosses a network.

Shipped it to production on a custom domain

Deployed as serverless functions against hosted SQLite, with DNS, TLS and automatic deployment from source. It is deliberately invisible to search (noindex headers, a served robots.txt and edge middleware refusing scrapers), and the build fails on a class of bug that silently produces wrong data in production but passes every local test.

A sub-second conversational loop across five models

Mic → Whisper transcription → uncensored LLM → neural TTS → per-frame facial animation → browser, orchestrated as one pipeline with a measured p50 of 848 ms and p95 of 1,168 ms over instrumented turns.

Interruptible turns implemented as a state machine, not a queue

Barge-in cuts the current reply mid-sentence and flushes the frame and audio queues. That's the difference between a chatbot taking turns and a conversation.

A dual-engine avatar renderer with per-chunk engine selection

A health probe (healthy && gpu_available && model_loaded) decides between a diffusion talking-head engine and a keypoint-based compositor on every speech chunk, with automatic fallback so a mid-session engine failure degrades instead of dropping the call.

Per-stage latency instrumentation with explicit budgets

Every turn records endpointing, STT, LLM first token, TTS first chunk, first video frame and transport against a 950 ms felt-latency target, and names the worst offender. That's how we know the renderer has the largest margin (p50 67 ms against 200 ms) and the language model is the real bottleneck.

Zero-shot voice cloning with a graceful hybrid path

A persistent voice from roughly ten seconds of reference audio, with automatic fallback to preset neural voices and word-level timestamps so lips, subtitles and audio share one clock.

Thirteen self-hosted GPU services orchestrated as one system

Speech recognition, language, two TTS engines, two face engines, video generation, pose and image generation, with health probing, VRAM budgeting and generation caps that reject oversized jobs before they reach a GPU.

A bare-metal cloud-GPU deployment kit

Cloud GPU pods are a single container with no Docker daemon, so the installer builds the entire stack as processes onto a persistent volume: idempotent phases, resumable after preemption, with a baked template image that cuts boot to minutes and profiles that spend 80 GB of VRAM deliberately across competing workloads.

A stable-address edge proxy solving ephemeral infrastructure

Rented GPU pods get a new hostname every boot and route by that hostname, so DNS alone can't reach them. An edge worker resolves the current pod from a key each pod publishes at startup, serves a branded page when nothing is running, and makes the identity-provider configuration a one-time job instead of a per-session chore.

Static audit tooling that walks the real graphs

Extracts the server's route table from its mount expressions, walks the frontend's import graph and the visitor's link graph, and fails the build on dead links, unserved endpoints, buttons nothing listens for, and imports that resolve only on case-insensitive filesystems: the class of bug that builds on Windows and dies on Linux.

The full product surface, tested and typed

A 63-page Next.js marketing site and a 28-view authenticated portal over 202 backend routes, sharing one purpose-built design system with scroll-choreographed motion, behind Auth0 sessions, WebRTC transport, and Drizzle migrations with a guard that refuses to boot against the wrong database. 586 passing tests and a clean typecheck.