Arthur Hovhannisyan
JavaScript frontend lead · Billups
“The project made my move from frontend engineering to Rust backend systems visible in code.”
Arthur came into the engagement a Lead Software/Frontend Engineer at Billups, with a strong record in performance, delivery automation, and frontend architecture. The Rust project had to add backend proof, so we focused on a video processing servicewith a Next.js client and an Axum backend that owns upload, inspection, and compression.
Over 211 commits, the project grew from upload UI to a real media pipeline: streamed multipart input, ffprobe metadata inspection, ffmpeg compression, JWT/Argon2 auth, SQLx/Postgres, and generated API types between frontend and backend.
Backend systems proof, not another frontend project
Arthur's resume was already strong on the frontend: performance work, release automation, and architecture ownership. The gap was proof of real backend and systems Rust, not another UI. Getting that right meant owning a pipeline that couldn't be mistaken for frontend work: a separate Rust backend with Axum routes, external process control, streaming I/O, auth, and database boundaries at its core.
The frontend still mattered, but as a real client for the pipeline: upload a video, inspect its metadata, compress it, and download the result.
- •Next.js upload flow with progress and cancellation
- •Axum + Tokio process orchestration around ffprobe and ffmpeg
- •100 MB body cap, timeouts, rate limiting, and streamed output
A working video service, 211 commits in
Arthur has a video processing service with a Next.js/React frontend, an Axum/Tokio backend, ffprobe inspection, ffmpeg compression, and a typed OpenAPI client generated from the server.
He's still Lead Software/Frontend Engineer at Billups, now backed by real Rust systems experience: Axum, Tokio, process control, streaming I/O, SQLx, Postgres, and deployment automation.
- ✓211 real commits across a complete upload and processing product
- ✓A backend/media Rust project, not another frontend build
- ✓Auth, external process safety, and deployment now backed by code
A real media pipeline, not another frontend demo
Arthur came in as a Lead Software/Frontend Engineer at Billups, with the frontend and delivery discipline to build polished products. The Rust project needed to prove backend systems judgment, so we scoped a video processing service around a real upload and compression flow: Next.js in front, Axum at the core, and ffmpeg doing expensive work behind a typed API.
- ✓Multipart uploads streamed to disk instead of buffering full videos in memory
- ✓JWT and Argon2 authentication with SQLx/Postgres persistence
- ✓OpenAPI-generated TypeScript client keeps frontend and backend contracts aligned
Next.js in front, Axum at core
Video UI
drop zone + progress
Axum API
inspect + process
Data layer
SQLx + Postgres
API server
inspect · process · auth
/inspect
ffprobe metadata
/jobs
ffmpeg process
Auth
JWT + Argon2
The expensive work is explicit and guarded
The interesting part is not the button that says Compress. It is the pipeline behind it: stream the upload, inspect it with ffprobe, spawn ffmpeg with a fixed preset, and stream the result back without blocking forever.
- ✓ffprobe metadata inspection separated from ffmpeg compression
- ✓libx264 CRF 23, AAC 128k, and a 300-second processing timeout
- ✓TempDir cleanup, process kill-on-drop, upload progress, and cancelable requests
Upload, inspect, compress, stream
Upload
multipart → TempDir
ffprobe
20s inspect timeout
ffmpeg
x264 CRF 23
Stream result
ReaderStream · attachment download
libx264
video codec preset
aac · 128k
audio output
A media service with real production guardrails
Over 211 commits, the project grew beyond a happy-path demo into a structured service: auth, video inspection, compression, generated API types, deployment config, and production guardrails. Arthur is still leading frontend engineering at Billups while building a credible backend Rust story around work he can defend line by line.
- ✓211 commits across backend, frontend, deployment, and API generation work
- ✓Production-only video rate limiting with a 100-request burst configuration
- ✓Docker, nginx, GitHub Actions, and local OpenAPI generation around the app
Guardrails around expensive work
JWT + Argon2
auth boundary
Rate limit
100 requests / hour
Docker + nginx
deployable service
OpenAPI codegen
typed frontend client
The journey
One clear path through the build
Upload
Next.js drop zone sends an MP4 multipart payload with progress and cancellation.
Inspect
Axum streams the upload to temporary disk, then ffprobe maps video metadata.
Compress
ffmpeg runs libx264 with CRF 23 and AAC audio through a guarded Rust process.
Download
The processed file streams back as an attachment and downloads as MP4.
Ship
JWT and Argon2 auth, SQLx/Postgres, OpenAPI generation, Docker, nginx, and CI.
Drag to explore · Select a milestone to read the full story
Mentor perspective
Arthur Hovhannisyan already knew how to build software, but needed to prove he could carry that judgment into backend Rust. He went deep on one real system instead of collecting frontend demos, then turned a video processing pipeline into evidence he could ship and explain.
Max Wells
Rustify mentor
Want a story like Arthur's?
Available for callsMax Wells
Founder · Rustify
Book your Rust career diagnostic
30 minutes, 1:1 with Max. An honest read on where you are and whether Bootcamp or Mentorship fits, before you apply.
Only a few diagnostic slots left this week.
Applications are reviewed carefully.
More client journeys
