Backend Engineer resume example

• Implemented schema validation in a Node.js ingestion API before publishing to Kafka. Used PostgreSQL reconciliation to detect acknowledged but unpersisted events; moved acknowledgment after durable enqueue and eliminated the loss in timeout replay tests.
• Improved distributed systems reliability by testing retry storms and delayed consumers. Used Redis expiry bounds and a dead-letter queue to isolate poison messages; verified that valid customer events continued processing during recovery.
• Reworked a Rust capture handler using benchmarking and profiling on a fixed 20,000-event/s replay. Bounded decompression and moved validation before allocation, reducing p95 acknowledgment latency from 180 ms to 112 ms without acknowledging events before Kafka persistence.
• Designed multi-tenant queue limits keyed by project and distinct ID. Isolated one high-volume client in an overflow lane, then checked data integrity against Kafka offsets and PostgreSQL identity mappings; healthy tenants retained their latency target during a 3× traffic spike.
• Built observability around consumer lag, retry volume and end-to-end ingestion delay. During an on-call incident, traced a stalled partition to a poison event, replayed the quarantined batch and reconciled event counts before closing the incident; added the reproducer to the canary release gate.
• Traced a timeout from the API handler to a contended database transaction; narrowed the lock scope and added concurrent-request tests for the retry path.
• Owned the PostgreSQL retry path using concurrent-request tests, eliminating duplicate writes while preserving the tenant-specific ordering of ingested events.
• Released a Go load-test fixture for Kafka ingestion and used profiling to isolate a lock bottleneck, reducing p95 request latency from 310 to 190 ms.

• Built a Go load-test client for the Node.js ingestion API, replaying timeouts and duplicate acknowledgments against PostgreSQL counts. Fixed the retry boundary and verified that recovered batches neither lost nor duplicated accepted events.
• At Datadog, implemented Go workers for a log-processing service and bounded Redis deduplication keys by customer and retry window. Replayed 2 million synthetic records with duplicated requests; PostgreSQL reconciliation found no missing accepted records after worker restarts.
• Migrated 36 PostgreSQL tables with expand-contract changes and a rehearsed rollback. Separated schema deployment from application rollout and verified old and new writers against the same fixtures; completed the change without stopping customer writes.

• At a payments software team, added contract tests for webhook signatures, repeated delivery and out-of-order events. Replaced manual release checks with replayable fixtures, catching a retry regression before the next customer integration shipped.

• Built a local event-replay harness with synthetic tenant traffic, a controllable Kafka outage and an S3 archive. Measured recovery time and checked unique-event counts before and after replay, making data-loss and duplicate-delivery failures reproducible in CI.
• Published the fixture generator, benchmark settings and failure matrix in the project report. Compared strict ordering with overflow isolation and recorded which consumer assumptions must change before either design can be deployed.
• Owned the independent regression fixture using isolated inputs, resolved a failing edge case and released a reproducible test package with expected outputs.

Relevant coursework: Algorithms, operating systems, databases, computer networks

Rust · Node.js · Go · Kafka · PostgreSQL · Redis

Tenant isolation · Data integrity · Observability

Load testing · Regression tests · Incident recovery

• Published an independent technical note using the project’s before-and-after traces, explaining the failed assumption, regression coverage and cases the implementation does not support.