Software Engineer resume example

• Built a Go ingestion worker that batches Kafka events into PostgreSQL, with idempotency keys and a replay test that caught duplicate writes after a timeout.
• Tested distributed systems reliability by stopping a consumer during replay; bounded Redis deduplication keys and queue backpressure kept recovery from exhausting memory.
• 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.
• Added Kafka consumer-lag and dead-letter alerts with tenant identifiers; linked each alert to replay commands and verified that a repeated event did not create a second record.
• Owned a Kafka ingestion replay test using tenant-isolated fixtures, resolving duplicate PostgreSQL writes without changing the ordering contract for other tenants.
• Released a Go benchmark harness for the ingestion path and profiled allocation hotspots, reducing peak memory by 21% on the same captured workload.

• Implemented schema validation in the Node.js producer before events reached the Go worker. Replayed incompatible payloads in a contract test and prevented malformed events from entering Kafka while preserving the failed request for diagnosis.
• 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.