BuenosCoders

Senior Fullstack AI Platform Engineer

Event sourcing treated as an operational primitive rather than a doctrine. Context as files, not a database of prompts. Twenty years of delivery across PHP, Python, and TypeScript.

Available for contractor work Buenos Aires, UTC-3
01 — About

How I work

I've built systems that are still running many years later.

Most of my work has been the unglamorous half of a platform: message queues that do not lose work, event logs somebody can actually replay at an inconvenient hour, and deployment paths that a small team can operate without a runbook. The architecture matters less than whether it holds up under load and whether the next person can reason about it.

On AI systems specifically, I have settled on context as files: prompts, schemas, and reference material kept as versioned text instead of a database of prompt rows, because that is the only form in which a behaviour change arrives as a diff somebody can review. The discipline is in keeping the kinds apart. The application, its documentation, and the development loop each need something different out of it, each one goes wrong in its own way, and each one gets its own rule about where it lives and what checks it.

Every company that exists is the consequence of a series of events, so choosing events as the primitive and projecting database views from them is the right call early. It is the model that matches what the business actually is. When scaling accelerates, more systems, more teams, more infrastructure, the projections can be rebuilt to match and the organisation can follow. Starting from projections and trying to recover the history later is the expensive direction.

02 — Strengths

Strengths

Depth across the stack, weighted towards the parts that fail under production load.

01

Distributed systems

RabbitMQ, async-first service boundaries, and CQRS where the read and write models have genuinely diverged.

02

Event sourcing

Events as the primitive, database views projected from them. A model that matches what a business actually is, so it scales without a re-architecture.

03

AI context as files

Prompts and schemas versioned as repository text, documentation pinned to the commits it describes, and development context deliberately kept out of version control.

04

API design and consumption

Building them and integrating against other people's, which is where the versioning and error contracts get real.

05

Data and integrations

SQL and NoSQL, plus the unglamorous work of wiring systems that were designed independently of each other.

06

Platform

Docker, Linux and Debian, deployment pipelines sized for a team that has other things to do.

03 — Method

Context is not one thing

The application needs context to run. People need documentation to read. The development loop needs context of its own. Three audiences, three owners, three ways to go quietly wrong, so each one gets a different guard.

Runtime context deployed

context/
context/what the running system loads
system.mdrole, scope, constraints
glossary.mddomain vocabulary
schema/
orders.jsonvalid output shape
refunds.jsonvalid output shape
prompts/one concern per file
classify.mdversioned, diffable
extract.mdversioned, diffable
evals/fixtures, run in CI

The only context the running system reads. It ships with the application, which makes every edit to it a behavioural change, so it is reviewed like source and diffed like source. There is nowhere for it to hide and no reviewer who cannot read it.

Project documentation pinned

docs/
docs/written for the next reader
architecture.mdwhy it is shaped this way
decisions/one immutable file per decision
0001-events-as-primitive.md
0002-rebuild-projections.md
operations/for three in the morning
replay.mdrebuild a projection
rollback.mdrewind a projection

Documentation that cites code is a claim that decays quietly, so a claim in it carries the commit id it was written against and a pipeline step fails when the code has moved on without the note being revisited. A reference nobody can check is a reference nobody should trust, which is the same reason tests exist.

Development loop gitignored

.dev/
.dev/context about the work
tasks/how a change gets framed
runbooks/commands, in the order I run them
scratch/probes, deliberately disposable

Neither what the application needs nor what it ships. This is how the work is framed, which command does what, what was tried and thrown away. It stays under an ignored path on purpose: it promises nothing to a future reader, and committing it would dress it up as a promise it never made.

git+rev-parse HEADpins a reference to a fact. A bare file path is a promise to check later.

04 — Principles

Principles

The rules I hold myself to when nobody is reviewing the pull request.

01 Make the failure mode boring

Prefer designs where the bad case is a rejected message or a visible error over one where it is silent data corruption. Boring failures are ones you can page on at three in the morning and reason about without a debugger.

02 Version everything the model reads

If a model consumes it, it is an artefact with an owner and a history. Context belongs in the repository next to the code that depends on it, reviewed in the same pull request, because that is the only place a diff is meaningful.

03 Solid means deleting code, not adding layers

Abstractions earn their place by removing a decision. When a layer only forwards calls or wraps a type, it is cost without benefit, and it is usually a sign the boundary was drawn in the wrong place.

04 Async is a design commitment

Moving a call into a queue changes the shape of the system, not just its latency. It means designing for retry, idempotency, and ordering up front, because those constraints do not arrive later for free.

05 The next person is the real consumer

Code is written once and read many times, usually under worse conditions. Optimise for the reader who is tired, in a hurry, and missing the context you had three months ago.

05 — Availability

Open to

What I am currently taking on.

Contractor work

Fixed-scope or long-running engagement.

Zero to one delivery

Greenfield systems taken to production.

Coaching

Async architecture and event-driven design.

06 — Contact

Get in touch

Describe the problem, the constraints, and roughly when you need it working. I reply to everything.

Write to Javier Contractor & coaching

I answer as soon as I can.