Dmitry Starodubtsev

Backend & AI Engineer

Dmitry
Starodubtsev

Building production RAG pipelines, tool-calling agents with memory, and multi-tenant backends with scalable AWS infrastructure. Michigan State CS '26.

ERP in production

7th largest K-12 district in Illinois

AI platform in production

5 university partners, US & Global

About

Backend and AI engineer specializing in production RAG pipelines, tool-calling agents with memory, and multi-tenant backends with scalable AWS infrastructure. At APS Data Technologies I've shipped systems serving the 7th largest Illinois K-12 district and 5 university partners — owning backend architecture, deployment, and the AI features end-to-end.

I build things that hold up in production, not just in demos.

Career

Experience

April 2025 — Present

Software Engineer

APS Data Technologies — EdTech B2B

Building production RAG pipelines, tool-calling AI agents with per-user memory, and multi-tenant backends with scalable AWS infrastructure serving the 7th largest Illinois K-12 district and 5 university partners. Owned backend architecture end-to-end for async processing, vector search, and a capability-based RBAC system districts use to manage their own roles and permissions at runtime.

September 2024 — April 2025

Software Engineer

Safety Straw — Seed-stage Safety Tech Startup

Built an AI support agent with custom tools and sub-agents that resolved 80%+ of customer inquiries autonomously. Shipped the REST API backend with Stripe integration and async order workflows, plus the React storefront end-to-end as the sole engineer.

September 2024 — May 2025

Operations & Growth Lead

Imagine Software — Student Organization

Scaled student tech org 55% from 450 to 700 members. Conducted 20+ technical interviews for client project staffing.

Aug 2022 — May 2026

B.S. Computer Science, Business Minor

Michigan State University

GPA 3.75. SpartaHack XI Blockchain Track 3rd Place (among 100+ teams).

Case Studies

Selected Work

Production Work

ERP Platform for K12 Schools

2025 — Present

Multi-tenant ERP connecting HR, payroll, and staff provisioning for K-12 school districts. Replaces manual clock-in, paper-based hiring workflows, and IT-gated access changes. Serves 1,650+ daily active users at the 7th largest Illinois school district.

Backend Engineer @ APS Data Technologies

Django RESTCeleryNext.js 15PostgreSQLAWSTerraform

Problem

  • Districts were running HR, payroll, and staff provisioning across disconnected systems: background checks in one vendor portal, payroll setup in another, timesheets on paper. There was no single place to see a candidate or employee's full status.
  • Access control was binary: a role either had module access or it didn't. Districts with 50+ role types and constantly shifting responsibilities had no way to express that without developer intervention and a redeploy.
  • Candidate screening was fully manual. HR staff reviewed applications one by one, which took 2+ hours per batch and became a bottleneck every time a district tried to expand hiring.

What I Built

  • Async hiring pipeline (Django + Celery + Redis) with idempotent retry logic and a dead-letter queue that cut candidate screening from 2 hours to 12 minutes.
  • Capability-based RBAC following module.submodule.action, deny-by-default. A central permission registry materializes into the database on deploy and is the single source of truth; stale grants are purged on every update.
  • Tool-calling AI agent connected to background-check and payroll APIs via tool calls, with per-user memory persisting each person's recurring queries across sessions.
  • REST API powering a Next.js 15 + React 19 frontend with Zustand-managed candidate state. DocuSign integration for offer signatures, SSO for district-wide auth.
  • Timesheet and onboarding modules integrated with each district's existing payroll system via nightly exports and API calls, so no district had to replace infrastructure they already ran.

Architecture Decisions

  • Celery workers for the hiring pipeline keep expensive screening operations off the API request path. Idempotent tasks with a dead-letter queue mean a Redis blip doesn't silently drop a candidate.
  • RBAC modeled as capabilities rather than roles-with-flags, similar to Kubernetes resource access. A missing grant means denied with no separate deny rules to maintain, which made the permission model auditable and meant districts could reason about it without reading code.
  • Permission enforcement mirrored identically on the backend (DRF permission classes) and frontend (route and component gating) so UI state and API access never diverge. Live changes propagate to active sessions within 60 seconds with no re-login.
  • AI agent uses tool calls to query live payroll and HR data rather than a knowledge base, because status questions need current records and not a cached snapshot from the last embedding run.

Infrastructure

  • Multi-tenant architecture with per-district data isolation enforced at the query layer, so every request is scoped to the caller's tenant and role before any business logic runs.
  • AWS (ECS, RDS, S3, Terraform) supporting 1,650+ DAU and 500 AI-processed resumes per day. Autoscaling thresholds and connection pool limits sized to actual load profiles.
  • CloudWatch alerting on P99 latency, container logs, and error rates across dev/staging/prod environments.

Impact

  • Hiring pipeline cut candidate screening from 2 hours to 12 minutes, which moved HR teams from manual review marathons to same-day decisions.
  • Districts manage roles and permissions entirely through the admin UI. A change that previously required a developer and a deploy now takes minutes with no tickets filed.
  • AI agent reduced time on routine ERP tasks 5x by pulling from background-check and payroll portals through a single interface instead of three separate logins.
  • Replaced paper-based timesheets and manual onboarding steps; new hire data syncs to payroll automatically without replacing existing district infrastructure.

Admissions & Career Platform for University Partners

2024 — 2025

AI-powered student support platform embedded with 5 university partners across the US and India. Guides international students through US college applications, internship searches, hackathons, and financing. RAG pipeline with cross-encoder reranking and per-user memory handles 200+ daily queries at 95%+ retrieval accuracy.

Backend Engineer @ APS Data Technologies

Django RESTQdrantOpenAILangGraphAWS S3/ECS/RDSDocker

Problem

  • International students applying to US colleges are navigating a process that doesn't map to anything they've seen before: different application timelines, financial aid structures that don't translate, and placement tests with no obvious prep path.
  • University advisors can't scale to 200+ individual questions per day across multiple time zones. Most guidance was either generic or delayed until business hours in a completely different hemisphere.
  • Each student's situation is different: their documents, their target schools, their visa situation. Generic advice doesn't help, so the system needed to answer questions grounded in each student's actual application materials.

What I Built

  • Async OCR pipeline that parses each student's uploaded documents on intake (essays, transcripts, resumes), extracts structured data, and embeds it into the vector store for personalized retrieval.
  • Production RAG pipeline with OpenAI embeddings stored in Qdrant and a cross-encoder reranker re-scoring top-k candidates before context is passed to the LLM.
  • Per-user memory layer (Postgres-backed, LangGraph orchestration) scoped to document metadata and session summaries, which tracks where each student is in the process across sessions without context window bloat.
  • Evaluation harness of 100+ query/document pairs against a 1k+ document corpus. Tuned chunk size, overlap, and similarity threshold against the same fixed eval set, each variable changed in isolation.

Architecture Decisions

  • Cross-encoder reranker as a second pass after semantic retrieval, where embedding similarity surfaces candidates by topic and the reranker re-scores them by actual relevance to the specific query. Closes the gap on questions where the right document isn't the most similar one.
  • Semantic chunking for knowledge base documents (splitting on similarity drops between adjacent sentences) rather than fixed-size chunks, which preserves coherent policy and process context that fixed windows would split mid-thought.
  • Student-uploaded documents (essays, transcripts) chunked by natural structure rather than token count, so an essay is embedded whole and a transcript is chunked by semester. The retrieval unit should match how the document is queried.
  • Retrieval misses return a structured 'not found' response rather than a best-guess answer, because a confident wrong answer about a visa deadline or financial aid cutoff is worse than no answer.

Infrastructure

  • AWS: ECS for container orchestration, RDS for managed PostgreSQL, S3 with pre-signed URLs for secure document storage.
  • Three-environment setup (dev/staging/prod) with CI/CD pipeline for automated deployments and rollback. Docker Compose for local development parity with production.

Impact

  • 5 university partners onboarding students directly; 200+ daily queries handled at 95%+ retrieval accuracy across partners.
  • Students get answers grounded in their own uploaded documents, specific to their essay, their transcript, their situation, not generic college advice.
  • OCR pipeline replaced manual per-applicant document review; documents are parsed, chunked, and embedded automatically on upload.
  • Per-user memory means returning students don't re-explain their situation each session since the agent already knows where they left off.
  • Some integrations omitted from the demo for confidentiality; the architecture shown represents the core production system.

Safety Straw

2024 — 2025

Full-stack build for a seed-stage startup making straws that chemically glow when a drink has been spiked. Owned the website, Stripe-integrated checkout, async notification system, and an AI agent for B2B order management.

Software Engineer @ Safety Straw (Seed-stage Startup)

Node.jsExpressMongoDBStripeReactCI/CD

Problem

  • Safety Straw sells a hardware product through two distinct channels: individual consumers (B2C) and bars, venues, and event organizers buying in bulk (B2B). Both needed a working e-commerce experience before launch.
  • A small founding team can't staff a support queue. Venue managers ordering 500 straws have operational questions like order status, delivery timing, and restock thresholds that aren't worth routing to a human for every ticket.

What I Built

  • REST API (Node.js + Express + MongoDB) with JWT authentication powering checkout and order management end-to-end for both B2C and B2B flows.
  • Stripe integration for payment processing: checkout sessions, webhook handling for order confirmation, and async queues for post-purchase notification workflows.
  • Tool-calling AI support agent with custom tools and sub-agents that looks up order and shipment data through internal and third-party APIs, resolving 80%+ of customer inquiries autonomously.
  • Single codebase serving four surfaces: B2C storefront, B2B bulk order flow, editorial blog, and transactional notification service.
  • React storefront built to Figma designs. CI/CD pipeline (GitHub Actions + Docker) with tests and lint on every PR.

Architecture Decisions

  • Separate B2B bulk order flow from B2C checkout because venue managers need volume pricing and restock logic that doesn't apply to individual purchases, and mixing them would have made both worse.
  • AI agent uses tool calls to query live order and shipment data rather than a knowledge base. Order status is a live-data question; embedding it would give you a snapshot that's stale the moment a shipment updates.
  • Async queues for post-purchase notifications decouple payment processing from notification delivery, so a slow email provider doesn't hold up the checkout response.
  • Agent escalates cleanly when a query is outside its tool coverage rather than guessing. B2B clients notice when an agent hallucinates an order status.

Impact

  • AI agent resolved 80%+ of customer inquiries autonomously, which removed manual ticket triage for the majority of support volume at a company with no dedicated support staff.
  • Shipped 25% ahead of schedule as the sole engineer across backend, frontend, payments, and AI.
  • Async notification system handles the full post-purchase flow end-to-end without manual intervention across both B2C and B2B channels.

Other Projects

Multi-Agent Simulation Engine

2026

Real-time civilization simulation supporting up to 50,000 concurrent agents. The scheduler is world-agnostic: any simulation plugs in by implementing a single DoAction interface, and the scheduler stays completely blind to agent and action types. Scaled using a 4-tier priority system (critical/gameplay/environment/misc) with async job queues, separating deterministic combat from construction tasks to prevent frame stalls.

Product Lead — Team of 30 (18 commits)

Scheduling Architecture

  • Implemented stride scheduling where processes track virtual time position, with stride inversely proportional to priority. The scheduler always advances the furthest-behind process, ensuring fair proportional CPU allocation across 50,000+ agents.
  • Organized execution into 4 tiers (CRITICAL 40%, GAMEPLAY 30%, ENVIRONMENT 20%, MISC 10%) with independent Scheduler instances per tier via composition.
  • Set per-tier budgets with soft enforcement for CRITICAL (250ms overage allowed) and hard cutoff for others, preventing lower-tier processes from starving critical gameplay loops.
  • Built in C++23 compiled to WebAssembly via Emscripten, designing clean interfaces between world state, agent behaviors, and rendering systems for a distributed 30-person team.
  • Verified correctness across unit tests (Scheduler add/remove/priority/peek), integration tests (budget enforcement, tier isolation, edge cases), and starvation scenarios.

Academic engineering project focused on architecture and correctness, not business metrics.

C++23WebAssemblyEmscriptenStride SchedulingUnit Testing

QuiKard

2025

Built a digital business card service: create in under a minute, export to Apple Wallet without signing up, share via NFC tap.

Solo Developer

  • Next.js 15 + TypeScript frontend with Tailwind styling, FastAPI + SQLAlchemy backend on PostgreSQL/SQLite.
  • Integrated Apple Wallet Pass API to generate .pkpass files on-the-fly, enabling NFC tap sharing directly from iPhone Wallet.
  • Each card gets a unique shareable URL and auto-generated QR code for distributing physical cards without typing or links.
Next.js 15FastAPIPostgreSQLApple Wallet APITypeScriptDocker

CourseChecker

2025

Course review aggregator where only verified university students (via school email) can submit reviews. Tracks 5 rating dimensions (overall, difficulty, materials, workload, fairness) per professor and semester.

Lead Developer (85 of 153 commits)

  • Tracks 5 independent rating axes (overall, difficulty, materials, workload, fairness) with granularity per professor and semester.
  • Implemented pagination and incremental data fetching so the UI stays responsive as review count grows, avoiding full dataset loads on mount.
  • Used Supabase RLS to enforce per-student data isolation, handle school email domain validation, and provide OAuth without custom auth infrastructure.
Next.js 14SupabaseGPT-4TypeScriptTailwind

Volunteer Matchmaker

2026

Volunteer matching system using composite scoring across proximity, skills, urgency, and reliability. Integrated Ethereum smart contracts for on-chain donation tracking. Won SpartaHack XI Blockchain Track 3rd Place.

Team of 4 — SpartaHack XI | Blockchain Track 3rd Place

  • Scoring algorithm weights proximity (geodistance), skill overlap, job urgency (time-decay for stale requests), and volunteer reliability rating to produce ranked matches.
  • Built real-time messaging between matched volunteer and requester without exposing personal contact info, using JWT-authenticated channels.
  • Deployed VolunteerLeaderboard smart contract on Ethereum for transparent donation tracking, integrated to frontend via Ethers.js.
Next.js 15Django RESTGemini AISolidityZustand

Toolkit

Technologies

AI / ML

  • RAG Systems
  • Vector Search (Qdrant)
  • LLM Integration (GPT-4, OpenAI API)
  • Embeddings
  • Cross-encoder Reranking
  • Agentic Systems (Tool Calling, Memory)
  • Eval Design

Backend

  • Python
  • Django REST
  • FastAPI
  • Celery
  • Node.js
  • REST APIs
  • Async Processing
  • RBAC
  • Stripe

Frontend

  • TypeScript
  • React
  • Next.js
  • HTML/CSS
  • Tailwind CSS
  • Zustand

Infrastructure

  • AWS (ECS, RDS, S3)
  • Terraform
  • Docker
  • CI/CD (GitHub Actions)
  • CloudWatch
  • Autoscaling

Databases

  • PostgreSQL
  • Redis
  • MongoDB
  • Qdrant
  • SQLite