Hire me

Everything you need to decide, in one place. Watch the intro, read the resume, then judge the work.

01

Intro

Quick intro

A short walkthrough of how I work and what to expect from the rest of this page.

Takeaways

  • Backend-heavy full-stack work: APIs, data, automation, and integrations under real constraints
  • Digs for bottlenecks and owns the fix through deployment — not just the happy path
  • Looking for a small team where useful software and hard problems are the job
02

Resume

03

Portfolio

Diagnosing a Database Bottleneck with 4 Million Journal Lines

I built a repeatable benchmark to profile an accounting compilation pipeline, measuring execution time, CPU consumption, and memory across progressively larger datasets. The results revealed that database retrieval and row hydration—not the compilation algorithm—dominated execution time.

Takeaways

  • Developed a deterministic benchmark harness with stage-level instrumentation and memory profiling.
  • Identified a database retrieval stage responsible for approximately 85% of the 36.6-second compilation run.
  • Established local capacity measurements and identified streaming or pagination as the next optimization to evaluate.
04

System design

Design a rate limiter

Walking through throttling strategies and the tradeoffs between them.

Takeaways

  • Where the limiter sits in the request path, and why that placement matters
  • Token bucket vs sliding window: what each buys you and what it costs
  • How I'd scale the limiter for high traffic and handle common pitfalls (race conditions)

Designing a real-time checkers game

In this system design walkthrough, I design a real-time online checkers platform that supports 500,000 concurrent games and 10 million registered players. I explore matchmaking, real-time communication, database transactions, server scaling, and leaderboards, focusing on consistency, low latency, and efficient resource utilization.

Takeaways

  • Preventing Race Conditions: Use PostgreSQL transactions, row-level locking, and Redis Lua scripts to ensure players are matched correctly without duplicate assignments.
  • Scaling Real-Time Systems: Apply Little's Law to estimate system throughput, calculate server capacity, and design for 500,000 concurrent games.
  • Efficient Server Routing: Use consistent hashing to distribute games across servers and minimize disruption when servers fail or capacity changes.
  • Optimizing Matchmaking and Leaderboards: Leverage Redis sorted sets to efficiently match players by rating and retrieve player rankings without expensive database queries.
Video coming soon

Design a key-value store

Partitioning, replication, and consistency tradeoffs for a distributed store.

Takeaways

  • How I'd partition so a hot key doesn't take the whole store down
  • Replication vs consistency: the failure mode I'd accept first
  • What I'd measure before calling the design done
Video coming soon

Design a news feed system

Fan-out strategies and how to keep a feed fast at scale.

Takeaways

  • Fan-out on write vs read, and the traffic shape that picks one
  • Where ranking belongs so it doesn't block serving the feed
  • The cache I'd add last, after the data path is honest
Video coming soon

Design a web crawler

Politeness, dedup, and scaling a crawl without hammering the web.

Takeaways

  • How I'd stay polite without stalling the crawl
  • Dedup that actually holds once URLs start colliding
  • The bottleneck I'd expect first: fetch, parse, or store
05

Coding

Video coming soon

Big O Notation explained

What the notation actually buys you when comparing approaches.

Takeaways

  • Why O() is a decision tool, not a score
  • How I'd compare two solutions when n is small vs when it isn't
  • The cost that Big O hides: constants, memory, and the real bottleneck
Video coming soon

Linked lists deep dive

The operations that are cheap, the ones that aren't, and why.

Takeaways

  • When a list beats an array, and when it doesn't
  • Pointer bugs I'd watch for before talking about 'O(1) insert'
  • How I'd walk a list in an interview without losing the thread
Video coming soon

Sliding window

Turning nested loops into a single pass.

Takeaways

  • The shape of problem that is actually a window, not two pointers for show
  • How the window grows and shrinks without restarting the scan
  • The invariant I'd keep on the board so the code stays honest
Video coming soon

Prefix sum

Precomputing to answer range queries in constant time.

Takeaways

  • What I'd precompute, and what I'd refuse to precompute
  • Off-by-one mistakes that make the prefix array lie
  • When a prefix sum is the right cut vs when a tree would be
Video coming soon

Binary search

Beyond sorted arrays: recognizing when the pattern applies.

Takeaways

  • The predicate that makes binary search legal, not just 'the array is sorted'
  • How I'd pick lo/hi so the loop actually terminates
  • The interview problem that looks like search but isn't
Video coming soon

Slow vs fast sorting

Where O(n^2) sorts are fine and where they aren't.

Takeaways

  • When I'd still write insertion sort and mean it
  • What 'fast' costs: memory, stability, and worst-case behavior
  • How I'd explain the tradeoff without reciting a textbook
Video coming soon

Binary trees and binary search trees

Traversals, invariants, and what balance buys you.

Takeaways

  • The BST invariant I'd check before trusting a search
  • Traversals as tools, not rituals: which one answers which question
  • What unbalance does to the runtime, in concrete terms
Video coming soon

Heaps

Priority queues and the problems that reach for one.

Takeaways

  • The access pattern that says heap, not sorted array
  • What heapify actually rearranges, and why that's enough
  • A problem I'd refuse to force into a heap
Video coming soon

Graphs and graph traversal

BFS vs DFS, and picking the right one for the question.

Takeaways

  • The question that picks BFS: shortest path on unweighted edges
  • The question that picks DFS: components, cycles, 'can I reach'
  • How I'd represent the graph so the traversal isn't fighting the data
06

Contact

Questions, next steps, or just want to talk it through? Reach out directly.