I build systems that don't break at 3 AM. Backend developer focused on the unglamorous parts: correctness, reliability, and making operators' lives easier.
I design systems to prevent bad states from happening in the first place. Type safety, validation layers, state machines—boring stuff that saves you from midnight debugging sessions.
Your claims processor dealing with 200 submissions a day deserves a UI that doesn't make them want to quit. Bulk actions, clear errors, no cognitive overload.
When something fails in a reconciliation run, someone needs to understand why. I build systems where every error is traceable, explainable, and fixable without a developer.
Big bang releases are for people who like stress. I prefer incremental changes with clear rollback paths. Your production environment will thank you.
Data modeling matters. Normalize where integrity matters, denormalize for speed and auditability. Every schema decision is a bet on future maintenance pain.
Structured logging, correlation IDs, context at every level. When production breaks, you shouldn't need to deploy debug builds to figure out what happened.
Built a payment system that safely handles duplicate requests and network retries without charging users twice. Makes sure every payment or refund is recorded correctly, and each action can be traced later.
Built a system where placing an order triggers background steps like taking payment and sending notifications. Designed it so messages don’t get lost if the server crashes mid-way, and failed steps can be retried safely.
Batch tool that compares records from two systems (like bank vs internal data) and matches what should match. Anything that doesn’t match is grouped into clear “reasons” so a person can review and fix issues quickly.
Built a scheduler that runs background jobs on a schedule, with protection against running the same job twice. Keeps history of each run, saves errors, and supports rerunning failed jobs when needed.
Sends events to other systems (webhooks) with retry support when the receiver is down. Tracks delivery status, stores failures for later review, and allows replaying events when the target is ready.
Built a structured logging setup that makes debugging easier: each request gets a tracking ID and consistent logs. Helps answer “what happened?” quickly when something breaks in production.
Limits how many requests a user can make in a time window to protect APIs from spam and overload. Supports different limits per user type and works across multiple servers using Redis.
Upload system that supports large files and processes them safely in the background. Includes virus scanning, safe storage, and clear status updates so users know what’s happening.
I'm interested in backend-heavy roles where correctness matters more than move-fast-break-things. If you're building financial systems, government platforms, or anything where "it mostly works" isn't good enough—let's talk.
Stack: Python, .NET Core, Oracle/PL-SQL, React, API design, distributed systems patterns.