STAFF PLATFORM AND DISTRIBUTED SYSTEMS ENGINEER

Rafael Cardoso

I have spent 15+ years building backend platforms and enterprise integrations. At Synchro I progressed from Software Analyst to Senior Staff Software Engineer. This site documents my independent projects alongside that professional experience.

Read my resume GitHub profile

EMPLOYMENT / February 2011 - September 2024

Professional experience: Synchro

I progressed from Software Analyst to Senior Staff Software Engineer, designing fiscal integrations and guiding teams of 3 to 8 engineers through architecture decisions and code reviews. I turned recurring production failures into reusable validation checks and integration design rules.

Approximately 20 million fiscal transactions per week in the Synchro integration I designed and supported between Oracle ERP Cloud, electronic invoicing, and tax systems, using Java / Spring Boot and Apache Camel.

Historical employer-system workload, reported in my resume. This is not Octopus throughput, an independent-project benchmark, or a synthetic demo result. Employer code and operational measurements are not public.

Roles and dates in my resume

What I work on

Distributed systems
Message pipelines, offset-based deduplication, and recovery after interrupted processing. Octopus is my current independent implementation.
- Kafka
- Kubernetes
- Go
- Java
Enterprise integration
Fiscal integrations between Oracle ERP Cloud, electronic invoicing, and tax systems, including data validation and recovery from failed transactions.
- Java
- Scala
- Oracle
- PostgreSQL
Data platforms
Ingestion, embedding workers, and keyword and vector search. Atheros Search exposes processing state and the records behind each result.
- PostgreSQL
- Rust
- Go
Security and observability
Service authentication, role separation, deployment threat models, image digest pinning, and telemetry for diagnosing production failures.
- MCP
- Kubernetes
- Cloud infrastructure

Selected engineering work

Projects I built independently of my Synchro employment. Each includes a failure case, the implementation, and links to regression tests. Source links do not certify a current passing run.

Octopus

Independent project / Scala, Cats Effect, PostgreSQL

What I built: I built the durable ingestion coordinator: broker-coordinate evidence, persisted event/job/batch state, processor status, deduplication, leases, and fenced outbox dispatch.
Hardest failure mode: A process can stop after a database write or broker acknowledgement but before progress is committed. Delivery repeats, while one failed record can sit beside healthy work in the same batch.
How I addressed it: Persist scan-request state and ingestion evidence in one PostgreSQL transaction, reject changed payloads for an existing identity, and commit Kafka offsets only after durable handling. Restarts resume from committed group offsets. Stable dispatch keys and receiving-side deduplication tolerate the outbox acknowledgement/crash window. Expiring fenced leases reclaim work without authorizing stale completion.
Regression coverage: Repository tests cover persisted processor state, duplicate replay, changed-payload rejection, concurrent outbox claims, healthy peers surviving a permanent result failure, and completion waiting for every batch. PostgreSQL integration tests require Docker and can skip when it is absent.
Still unverified: These tests do not establish recovery time or a complete broker/database/process-crash campaign. At-least-once delivery can repeat. There is no exactly-once or zero-loss guarantee. Live ledger counts do not establish capacity.

Persistence implementation Replay and recovery integration tests Partial-failure tests Processor persistence tests Octopus workflow and live readings

Atheros Search

Independent project / Go, PostgreSQL, SolidJS

What I built: I built the retrieval service, leased embedding workers, and console for inspecting semantic, keyword, and fused search scores across source observations.
Hardest failure mode: An expired worker can finish after a replacement has claimed its job, publishing stale vectors. A failed embedding provider can also make the semantic search leg unavailable.
How I addressed it: Fence completion with lease tokens and content revisions, write vectors and job completion in one transaction, and expose a labelled sparse fallback when hybrid retrieval cannot use its semantic leg.
Regression coverage: Repository tests cover weighted reciprocal-rank fusion and deduplication, explicit fallback codes, lost-lease rollback, vector-write failure rollback, and stale-fence rejection against PostgreSQL.
Still unverified: No published relevance benchmark or latency result. Wireless observations and identity candidates do not confirm a current connection or physical device identity. The public sample is synthetic.

Retrieval fusion implementation Atomic worker completion tests Atheros product documentation

Schema Migrator

Independent tooling / Scala, Cats Effect

What I built: I built ordered SQL-file validation and planning, run records, and a review workflow that keeps offline checks separate from database execution.
Hardest failure mode: Ambiguous dependencies can produce an unsafe apply order. A failed or cancelled run can leave ownership behind and block recovery.
How I addressed it: Reject duplicate, missing, or cyclic dependencies before apply. Scope lock release to the protected action and cancel managed work so a started run can be recovered durably.
Regression coverage: Repository tests cover invalid dependency plans, rejection before apply, lock release after failure, and cancellation releasing a started run for durable recovery.
Still unverified: Offline checks do not establish target permissions, lock behavior, or reversibility of arbitrary DDL. SQL-file snapshots preserve source files and checksums. They do not back up database data. The sample executes no SQL.

Migration planning tests Run recovery tests Schema Migrator walkthrough

RCLabs VPN / Proxy

Independent project / Rust, WireGuard

What I built: I built the transparent proxy path for WireGuard traffic, classification, and audit-event publishing into the ingestion pipeline.
Hardest failure mode: Hostname suffix mistakes, fragmented headers, or reused HTTP connections can bypass request checks. Incomplete TLS metadata can also lead to an overconfident classification.
How I addressed it: Match domain boundaries explicitly, check each plaintext request before connecting upstream, and distinguish partial TLS ClientHello parsing from complete evidence.
Regression coverage: Repository tests cover exact suffix matches, fragmented blocked HTTP headers, per-request keepalive checks, missing SNI, and fragmented or incomplete TLS handshakes.
Still unverified: No Internet-wide classification accuracy, device-interoperability, or production-throughput claim. Traffic outside the configured path is not covered. The browser sample opens no VPN connection.

Classification implementation and tests Transparent proxy regression tests VPN / Proxy walkthrough

What I am looking for

A role where I can own backend systems, contribute to architecture, and work closely with an engineering team.

Role scope: Staff or principal engineering, engineering lead, or early technical leadership.
Best environment: Teams that give engineers responsibility for design, delivery, and production support.
Useful conversations: Backend and data-platform architecture, team structure, retrieval systems, and distributed-systems security.

Contact rafael@rclabs.uk github.com/zlovtnik

About the examples

The source and tests are from my independent projects. Browser samples use synthetic records. Synchro workload comes from my resume and describes the historical employer system. None establishes customer adoption or service-level commitments.

Repository threat model