With over a decade of experience in the Ruby on Rails ecosystem and backend engineering, I currently specialize in the convergence of traditional software engineering and Artificial Intelligence.

I build agentic workflows (LangChain, n8n, Anthropic Claude, Gemini, Amazon Bedrock) and design robust DevOps infrastructures — from zero-downtime Kamal 2 deploys to a self-hosted home lab exposed through a single Cloudflare Tunnel with no open ports. Lately my main line of work is verifiable compute: outputs that a third party can check without trusting whoever produced them, sold agent-to-agent over x402 micropayments — see NomiCheck below.

The through-line across all of it is a habit rather than a stack: measure before believing, including your own documentation. Every claim below that carries a number was measured, and the ones that turned out false are written down too — my own docs passed six straight audits while publicly serving a wallet I had already rotated, which is what taught me to build the auditors that compare prose against what the servers actually return.

When I'm not optimizing containers or integrating APIs, I enjoy structured swim training and exploring the intersection of technology and brand development within the hospitality and gastronomy sector — currently building the digital presence and point-of-sale system for Resplandor, a Colombian restaurant in La Estrella, Antioquia.

An interconnected view of my tech stack, projects, and areas of expertise.

The calculation is a commodity. The proof is not.

A Colombian payroll engine built around one idea: an answer nobody can check is worth very little. Live at nomicheck.ynt.codes.

Verify one end-to-end, in one click, with nothing installed and no account:

https://ynt.codes/verificar?url=https://nomicheck.ynt.codes/api/batch/verificar/ejemplo

Stack: TypeScript · Express · Prisma · PostgreSQL 17 · React 19 + Vite · pnpm monorepo · viem · Docker Compose on AWS Lightsail, with the home lab as a cold standby. The API and the web ship as one container on one port, and /api/health publishes the exact commit it is running.

Two hosts behind one front door, with no inbound ports on either. In August 2026 the whole public surface moved to a managed host; the home lab kept its tunnel stopped and became something else entirely — the agent fleet, the read-only panels, and a standby nobody can reach. Everything is designed, debugged, and documented with AI assistance.

Four different ways in — and no count in this heading on purpose: a number in a title is a claim nobody re-measures, and this one already went stale once. The table is the claim.

• Deploying a single persistent outbound tunnel with cloudflared to bypass CGNAT restrictions, eliminating the need for any open port on the home network.
• Architecting internal Docker networking so a freshly deployed Kamal container re-joins the right network-alias inside the proxy network without manual intervention.
• Tuning Kamal's drain_timeout well above the default so in-flight AI plan generations (up to ~120s) survive a mid-generation deploy instead of leaving jobs stuck.
• Running dev and prod against the same external Postgres instance safely, with clear guardrails around DATABASE_URL vs DEV_DATABASE_URL.
• Putting the payroll database on its own isolated Docker network, so cloudflared cannot reach it even if a routing rule is written by mistake — and moving Uptime Kuma off 0.0.0.0 after auditing what the host was actually listening on.
• Making the deploy measure what it served rather than what it intended: exporting a variable is not the same as delivering it to the container, and a deploy that silently didn't looks exactly like one that did.
• Rehearsing the failover instead of assuming it — moving production to a managed host and promoting the old one back, live, with zero requests dropped. A standby nobody has ever promoted is a hypothesis, not a backup.
• Learning why that standby now stays deliberately off rather than warm: with both copies running, they exhausted the database pooler's connections and split traffic across two versions of the app — which is how one tenant's login started rendering another tenant's brand. Failover is manual and one-way on purpose.
• Finding, while load-testing something else, that the per-IP rate limit was bypassable by rotating X-Forwarded-For (40/40 got through against a cap of 10) because the payment wall set trust proxy in a different file. The key now comes from CF-Connecting-IP.
• Keeping the public status panel in a separate process that never loads the wallet code at all — a guarantee an allowlist cannot give you, because it cannot leak what it never had in memory.

A set of small, deliberately boring collectors that answer one question each with my own numbers instead of somebody's screenshot. Every one of them started because a claim was circulating — a viral thread, a marketing figure, a rumor — and the honest way to settle it was to measure it.

They share one rule, and it is the interesting part: they measure, they never execute. No signing, no funds moved, no API key needed. They are outbound clients only — they listen on no port, on any machine. If a measurement ever justified acting on it, that is a different phase and a separate decision.

Findings land in trading-knowledge, an Obsidian vault where estado/ is the source of truth: dated, sourced, and authoritative over every other note. Signals carry an expiry — a detection whose market has closed is shown as expired, never as an opportunity. None of it is financial advice: it shows measurements against written rules, and the decision stays human.

Beyond the Home Lab, Artificial Intelligence is the core of my professional workflow, acting not as a replacement, but as an engineering accelerator.

  ┌─────────────────────────────────────────────────────┐
  │              AI Integration Stack                   │
  │                                                     │
  │  LangChain ────────► Agent Orchestration            │
  │  Anthropic Claude ─► Reasoning & Generation         │
  │  Gemini 2.5 Flash ─► Primary provider (multi-model) │
  │  Amazon Bedrock ───► Multi-model API Gateway        │
  │  RAG Pipelines ────► Embeddings + Vector Search     │
  │  n8n ──────────────► Multi-step Agentic Workflows   │
  └─────────────────────────────────────────────────────┘

Advance Fitness is the flagship application of this stack: a multi-tenant gym management platform (Rails 8.1 · Ruby 4.0.5) with AI-generated, editable training and nutrition plans through a provider adapter layer — gemini-2.5-flash by default, claude-sonnet-5 as fallback — deployed via Kamal 2 on the home lab and backed by Supabase. Four tenants run off the same deployment, each on its own hostname.

Alongside engineering, I design and build the digital presence — and increasingly the operational software — for small hospitality and e-commerce brands.

Stack: single-file HTML · Tailwind CSS (JIT via CDN) or design-system tokens with custom brand palettes · Alpine.js / React via CDN · Lucide Icons · AOS scroll animations · Google Fonts · Supabase for the POS and the salon queue.