Back End Developer - Veridian Engineering Group (Feb 2023 - Nov 2024)
Focus: Distributed backend systems, high-throughput data pipelines, security systems, CI/CD automation.
Backend Engineer | Rust, TypeScript, Node.js
Core Competencies
- System Architecture
- Anti-Cheat Development
- API Design & Service Architecture
- Application Security
- CI/CD & Automation
Primary Languages
- Rust
- C++
- TypeScript (Node.js)
- Python
Work Experience
Junior Backend Developer - Veridian Engineering Group (Sep 2022 - Feb 2023)
Focus: Legacy microservices maintenance, API development, test coverage improvements.
Software Developer Intern - Veridian Engineering Group (Mar 2022 - Sep 2022)
Focus: Automation scripting, bug triage, tooling improvements.
Infrastructure & Tools
- Rust, Cargo, Clippy (Static Analysis)
- Node.js, Express, NestJS
- PostgreSQL, MongoDB, MySQL, Redis, SQLite
- Docker, Kubernetes, GitHub Actions
- Kafka, Event-Driven Architecture
- Cloudflare (Workers, Pages, DNS), Nginx, PM2
- REST API, gRPC, JWT/OAuth
- Unit Testing (Jest, Rust testing)
- Git, Jira
Additional Experience
Familiar with Java, Lua, Pawn, C, C#, and various scripting languages. Primary focus on Rust, TypeScript, Python, and C++.
Philosophy
Simplicity over complexity. Boring technology that works beats bleeding-edge frameworks that hide their failures. Systems should be understandable, maintainable, and performant. Every abstraction leaks; choose the ones that leak predictably.
Technical Summaries
Persistent Key-Value Store (Rust, Write-Ahead Log)
Problem: In-memory data structures are fast but volatile. A crash or power loss results in total data loss. The fundamental challenge is making data durable without sacrificing performance.
Solution: Built a persistent key-value store from scratch, backed by a write-ahead log (WAL). All writes are first appended to a durable, on-disk log and flushed with `fsync` before the in-memory cache is touched. This guarantees that any acknowledged write can survive a crash.
Outcome: A crash-safe, single-file key-value store. The system recovers its state by replaying the log on startup. It includes a log compaction mechanism that uses an atomic rename to safely reclaim disk space from obsolete records. The implementation is fully unit-tested, proving its durability and recovery guarantees.
Source Code: [GitHub]
Recursive DNS Resolver (Rust)
Problem: DNS is a foundational internet protocol, yet most developers treat it as a magic black box. To understand the system at a fundamental level, I needed to build it from the ground up.
Solution: Implemented a recursive DNS resolver from scratch in Rust, adhering to RFC 1035. The project involves building and parsing DNS packets byte-by-byte, handling UDP communication, and walking the entire DNS hierarchy from the root servers down to the authoritative name servers for a given domain.
Outcome: A functional, command-line resolver that can resolve `A`, `NS`, and `CNAME` records without relying on any system-level or external DNS libraries. The parser correctly handles domain name compression and includes cycle detection to prevent malicious packets from causing infinite loops. The project is fully unit-tested and maintained with a CI pipeline.
Source Code: [GitHub]
Circuit Breakers (TypeScript, Node.js)
Problem: No circuit breaker pattern available for Node.js TypeScript projects. When a service fails, downstream services keep hammering it, causing cascading failures.
Solution: Built a Circuit Breaker library implementing Closed/Open/Half-Open states. Tracks failure counts and time windows. Exposes Promise-based API and emits events on state transitions.
Outcome: Library isolates failing services automatically. State changes trigger events for monitoring. Published as reusable package.
Source Code: [GitHub]
Useless Programming Language (Rust)
Problem: Wanted to learn compiler internals. Built a language from scratch to understand lexing, parsing, and AST construction.
Solution: Implemented lexer, parser, AST, and interpreter in Rust. Includes sarcastic error messages and random behaviors. Planning Tauri app for cross-platform GUI.
Outcome: Working language implementation with tests covering lexer, parser, and AST.
Source Code: [GitHub]
Markdown Converter (Rust, CLI)
Problem: Common Markdown converters generate bloated HTML and are slow. Needed file watching for live preview during writing.
Solution: Built Rust CLI tool with interactive interface. Minifies HTML output. Watches filesystem for changes and regenerates on save. Added KaTeX for math and syntax highlighting.
Outcome: Fast conversion with minimal HTML output. File watching provides instant previews. Math rendering and code highlighting work.
Source Code: [GitHub]
UPL VSCode Extension (TypeScript)
Problem: UPL needed IDE support. Without syntax highlighting, writing code is painful.
Solution: Built VSCode extension using TextMate grammars for syntax highlighting. Includes language configuration, auto-closing pairs, and code folding.
Outcome: VSCode extension provides syntax highlighting for UPL files with support for keywords, functions, strings, numbers, and booleans.
Source Code: [GitHub]
Discord Bot Template (TypeScript, Node.js)
Problem: Every Discord bot project starts with the same setup: command handlers, event listeners, middleware. Copy-pasting boilerplate leads to inconsistent patterns.
Solution: Created minimal template with TypeScript, TypeORM, Discord.js v14, SQLite, and Winston. Includes structured folders for commands, events, handlers, services, and utilities.
Outcome: Template eliminates repetitive setup work for Discord bot projects.
Source Code: [GitHub]