I rebuild pipelines other people have stopped looking at.
The one I'm proudest of: a regulatory-document ingestion platform that had been dark for two months, across 100+ ingestion configurations. I rebuilt it event-driven (Pub/Sub, Cloud Run, Terraform, Postgres) and — more usefully — gave it freshness SLOs and validation checks, so a silent failure goes from "someone notices missing data weeks later" to an alert in seconds. Same system, same stretch: took inbound email ingestion from one tenant to all of them, and put real Row-Level Security on tables that were exposed with permissive policies.
Current problem, my favourite kind: SCADA time series for renewable assets. One asset's backfill alone is ~758 series and 13M rows, and it pushed a Postgres instance from 8 GB to 16 GB before hitting a storage cooldown; a few assets of that is multi-TB a year. So I'm designing the warm/cold split — Parquet on GCS for cold, partitioned + BRIN'd Postgres for the hot window, plus a coverage catalog in Postgres so the agent can ask "series X, range Y, which partition, which object". The hard part is never ingest (~30 rows/s, trivial); it's range-scanning years of data without paying five figures a year to do it.
Two slightly unusual things about me:
- My degree is ocean engineering, not CS. I came to software through marine systems, so I reason in failure modes and invariants first and reach for abstractions second. In practice: I ask "what happens when this half-fails at 3am" before "which library".
- I use coding agents hard, behind evidence gates. My dev flow runs as staged agents where each stage must emit machine-checkable artifacts (run manifest, test evidence, reviewer brief, PR URL) before it's allowed to open a PR. Agents write the code; deterministic checks decide what ships. I don't trust what I haven't verified, including my own agents' claims.
Before this: gym-platform backend in Go — 88 production incidents root-caused, OTP costs down 30% from rate limiting I wrote, and a race condition that was quietly overbooking memberships. I like the bugs that only show up under concurrency.
Looking for backend / data-platform / infra roles at a remote-first company: async-heavy, real ownership, systems where correctness actually matters. Happy to talk about ingestion pipelines, queues, or Postgres at its limits.
Remote: Yes — remote for 4 years, currently for a London company
Willing to relocate: Yes for the right role (would need visa sponsorship)
Technologies: Go, Python, TypeScript, PostgreSQL/Supabase, GCP (Pub/Sub, Cloud Run, Cloud Scheduler, Workflows, Secret Manager), Terraform, Docker, OpenTelemetry, Qdrant, Redis
Résumé/CV: https://nawafilhusnul.com
Email: [email protected]
I rebuild pipelines other people have stopped looking at.
The one I'm proudest of: a regulatory-document ingestion platform that had been dark for two months, across 100+ ingestion configurations. I rebuilt it event-driven (Pub/Sub, Cloud Run, Terraform, Postgres) and — more usefully — gave it freshness SLOs and validation checks, so a silent failure goes from "someone notices missing data weeks later" to an alert in seconds. Same system, same stretch: took inbound email ingestion from one tenant to all of them, and put real Row-Level Security on tables that were exposed with permissive policies.
Current problem, my favourite kind: SCADA time series for renewable assets. One asset's backfill alone is ~758 series and 13M rows, and it pushed a Postgres instance from 8 GB to 16 GB before hitting a storage cooldown; a few assets of that is multi-TB a year. So I'm designing the warm/cold split — Parquet on GCS for cold, partitioned + BRIN'd Postgres for the hot window, plus a coverage catalog in Postgres so the agent can ask "series X, range Y, which partition, which object". The hard part is never ingest (~30 rows/s, trivial); it's range-scanning years of data without paying five figures a year to do it.
Two slightly unusual things about me:
- My degree is ocean engineering, not CS. I came to software through marine systems, so I reason in failure modes and invariants first and reach for abstractions second. In practice: I ask "what happens when this half-fails at 3am" before "which library". - I use coding agents hard, behind evidence gates. My dev flow runs as staged agents where each stage must emit machine-checkable artifacts (run manifest, test evidence, reviewer brief, PR URL) before it's allowed to open a PR. Agents write the code; deterministic checks decide what ships. I don't trust what I haven't verified, including my own agents' claims.
Before this: gym-platform backend in Go — 88 production incidents root-caused, OTP costs down 30% from rate limiting I wrote, and a race condition that was quietly overbooking memberships. I like the bugs that only show up under concurrency.
Looking for backend / data-platform / infra roles at a remote-first company: async-heavy, real ownership, systems where correctness actually matters. Happy to talk about ingestion pipelines, queues, or Postgres at its limits.