“Innovation distinguishes between a leader and a follower” ~ Steve Jobs.
I build complete platforms — front-end, back-end, mobile, agents, and the infrastructure that ties them together. Native iOS, Next.js, Node.js APIs, real-time systems, and AI-native architectures (RAG, function calling, MCP servers, multi-agent orchestration).
My flagship is the Yantissimo platform — a tire and wheel distributor's complete digital stack: native iOS app, Express backend, headless Shopify storefront. I built all three. I move and iterate fast. I prefer leverage over surface area: a single self-hosted gateway over per-agent BSPs, a pure-logic core package over duplicated UI logic, a hand-written iOS APIClient over a third-party SDK.
Plain deliverables, real recent examples. No jargon, no demos that never see customers.
Storefronts and web platforms that sell, schedule, and run the operation.
Native iOS apps that work offline, send push, and feel like the platform — not a wrapped website.
AI that does real work — not a chatbot demo. Document classification, sales follow-up, smart scheduling.
I connect the tools you already pay for so they stop being silos.
ERPs, dashboards, and tooling tailored to how your team actually works.
No skill bars. Each group lists where it's shipped, in production, today.
Production Express APIs with real test coverage, async jobs, modular middleware.
Next.js App Router + React 19 + TypeScript + Tailwind. Server Components, edge middleware.
Native iOS, MVVM, zero external deps where it matters.
Direct SDK use (not wrappers). Function calling with safety guards, hybrid RAG, MCP.
CRDTs, WebSockets, voice, multi-channel messaging.
Vercel + Railway production deploys. CI/CD via GitHub Actions, Electron for desktop.
Postgres-first, Supabase RPC for security-definer functions, Shopify GraphQL, schema design.
JWT RS256 with on-device keypair generation, Keychain on iOS, iron-session on web.
Sin sorpresas, sin cajas negras. Cada hito tiene un entregable concreto.
Una llamada larga sobre el problema real: quién lo vive, qué cuesta hoy, qué pasa si no se resuelve. Mapeo procesos y datos antes de hablar de tecnología.
Alcance, entregables, hitos y precio cerrado. Sin sorpresas a mitad del proyecto. Si algo crece, se renegocia explícitamente.
Itero en sprints cortos, mostrando avances reales en cada uno. Tu equipo ve el sistema crecer; nada de cajas negras.
Pruebas con datos reales, casos límite, y los flujos que tu operación ejecuta a diario. Cuando algo se rompe, tiene que romperse aquí — no en producción.
Salida controlada con rollback listo. Te entrego la documentación de operación y un walkthrough en vivo con tu equipo.
Acompañamiento posterior con SLA acordado. Resolución rápida, mejoras priorizadas, y reportes mensuales si los necesitas.
Custom enterprise ERP powering a tire & wheel distributor — 24+ modules across audit, sales, scheduling, productivity, and warranties, plus the API, native iOS app, and storefront it feeds.
The operational backbone of an entire automotive distribution business.
Yantissimo Platform is the custom enterprise ERP I built for Llantísimo, a tire and wheel distributor in Mexico — and the satellite backend and storefront it feeds. The platform runs daily operations: parsing Microsip exports for next-day audits, computing technician and salesperson productivity, generating quotes and invoices, scheduling installations, managing wholesale and retail orders, tracking warranties, and surfacing live KPIs. The whole organization works inside it.
A 24-module Next.js 16 ERP, an Express orchestration backend, a native SwiftUI iOS client, and a headless Shopify storefront — one Postgres, one team.
Production four-surface platform. The ERP is a Next.js 16 (App Router + Turbopack) app with route groups for protected staff, client portals, and public surfaces, plus 24+ feature modules ranging from auditoría (Microsip parser + KPI engine + reassignment workflow) to suite (sales / quotes / payments / invoices), mayoreo (wholesale), calendarios, equipo, garantías, and an embedded AI agent panel. The Express backend is the API the ERP, the iOS client, and the storefront all call into. The iOS client is hand-written SwiftUI with zero external dependencies. The storefront is a headless-Shopify Next.js front-end with vehicle-search wired through Wheel-Size API.
ERP YSSM (plataforma): Next.js 16.0 App Router with Turbopack, route groups for (protected)/(clientes)/(public)/api, Material UI + HeroUI + custom Tailwind 4 design tokens, FullCalendar + react-big-calendar + react-date-range for scheduling, Recharts for KPIs, react-dnd for drag-and-drop, Socket.io for real-time collaboration, jspdf + jspdf-autotable for in-app PDF generation, xlsx for Excel exports/imports, libphonenumber-js for phone normalization, bcrypt for auth. The auditoría module ships its own pure-function calc layer (lib/excel/parseAuditoria.js, lib/calc/reasigMO.js), state via AuditoriaContext with patchSession persistence, and a 60-test suite under tests/auditoria/ run via node --import register. Backend (yssm-backend) is Express + Postgres + MySQL with 41 modular routes, Shopify Admin/Storefront SDKs, OpenAI, Backblaze B2, Google Sheets, Puppeteer, and Jest + Supertest tests. Storefront extends Vercel's Next.js Commerce template with a custom 'Por auto' flow.
24+ modules under (protected)/: auditoría, ventas, suite, mayoreo, ordenes, cotizaciones, calendario, equipo, dashboard, agent, claude, campañas, configuración, garantías, inventario, reports, ramps, seguimiento, todo, snapshots, administración, myr — plus a (clientes) portal.
41 modular routes: auth, mobile-app, services, quotes, ventas, dashboard, shopify, scrapper, calendar, formula, qr, cron, liquidaciones, invoices, snapshot, …
Zero external dependencies — no SPM packages, no CocoaPods.
Vehicle search ('Por auto') wired through Wheel-Size API into the Shopify catalog — customers find tires by make / model / year.
┌──────────────────────────────────┐
│ CUSTOMERS │
│ iOS app · Web shoppers · Sales │
└───────────────┬──────────────────┘
│
┌───────────────────┬─────────┴─────────┬───────────────────┐
│ │ │ │
▼ ▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ YANTISSIMO │ │ YANTISSIMO │ │ YSSM ERP │ │ NEXORA AGENT │
│ iOS APP │ │ STOREFRONT │ │ (back-office) │ │ (sales agent) │
│ │ │ │ │ │ │ │
│ Swift 5.9 │ │ Next.js 15.6 │ │ Next.js 16 │ │ Node.js │
│ SwiftUI │ │ React 19 │ │ App Router │ │ Telegram + WA │
│ APIClient w/ │ │ Server Comps │ │ MUI · Tailwind │ │ OpenAI tools │
│ 401 retry │ │ Edge middleware │ │ Socket.io │ │ Cron reminders │
│ Keychain · Cache │ │ Wheel-Size API │ │ GitHub Actions │ │ │
│ APNs │ │ │ │ CI / Vercel │ │ │
└─────────┬────────┘ └─────────┬────────┘ └─────────┬────────┘ └─────────┬────────┘
│ │ │ │
└─────────────────────┴──────────┬──────────┴─────────────────────┘
│ HTTPS / JSON / JWT
▼
┌──────────────────────────────────┐
│ EXPRESS API (Node 20) │
│ yssm-backend · 167 files │
│ │
│ 41 routes · middleware stack │
│ JWT auth · 401 refresh │
│ Job queue · scheduled cron │
│ Jest + Supertest tests │
└────┬──────┬──────┬───────┬──────┘
│ │ │ │
┌───────────────────────┘ │ │ └──────────────────────────┐
│ │ │ │
▼ ▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ PostgreSQL │ │ MySQL │ │ Shopify │ │ OpenAI │
│ (primary) │ │ (legacy ETL) │ │ Admin + SF │ │ GPT + tools │
│ pg-format │ │ │ │ GraphQL │ │ │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Backblaze │ │ Google │ │ Puppeteer │ │ APNs │
│ B2 (media) │ │ Sheets │ │ (payment │ │ (push) │
│ │ │ bridge │ │ verify) │ │ │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘
Deploy: Backend → Railway Storefront / ERP → Vercel
iOS → TestFlight Auth keys → Keychain (iOS) / Postgres (server)
Two of the highest-leverage decisions in code. Both are simplified for legibility — the actual implementations have additional logging, retries, and instrumentation.
Each one is a real product: shipped, used, and built end-to-end. Toggle Technical for stack and architecture detail.
AI-assisted fitness, nutrition, and training companion for iOS, backed by Supabase + Claude.
Fitness Copilot is an iOS app that combines macro tracking, weekly training plans, lab-result reading, and an AI coach in one place. The app is bilingual-ready (currently Spanish) and designed around how athletes actually use their phone — quick logging, glanceable timelines, and AI conversations that have real context about your goals, allergies, and recent labs.
Tab-based SwiftUI with a clean MVVM layer. Auth bootstraps via a centralized AuthService injected through a custom environment key. The backend (Supabase) holds dietary plans, lab reports, supplement schemas, and HealthKit-synced metrics. An Edge Function calls Claude with rich dietary context to generate supplement suggestions.
FitnessApp bootstraps AuthService via @StateObject. Repository is injected via a custom EnvironmentKey (\.repository) so views can swap between live and mock implementations cleanly. Theme tokens (Tokens / F / CardStyle) are abstracted away from views. NEXT_STEPS roadmap details HealthKit observable wiring, supplement RLS policies, and the Claude Edge Function contract.
Vehicle Routing Problem (VRP) visualizer with smooth MapKit truck animation, scoring formulas, and threshold tuning.
Kiosko Logistics is a route-planning dashboard for fleet operators. It animates trucks along their assigned routes on a real map, shows live scoring against custom formulas, and lets operators tune the constraints (time windows, capacity, distance weighting) without touching a config file.
VRP is NP-hard; the app is the visual & tuning surface for an upstream solver. The dashboard models VRP configuration, solution parsing, formula presets, and scoring thresholds as separate domain objects. Truck animation interpolates positions along route polylines without map jank.
Observable view models (modern Swift macro-based observation, not @ObservableObject) for VRPConfig, Dashboard, and RouteAnimation. RouteAnimationViewModel runs an async loop with Task.sleep(for: .milliseconds(50)) to walk truck position along the route polyline. Formula presets and threshold configs are value types so they can be diffed and persisted.
Hybrid RAG platform: documents → OpenAI Vector Store, structured data → Supabase, all answered through one ChatKit interface.
DataKnife is a single chat surface that answers questions across both unstructured documents (PDFs, contracts, manuals) and structured data (CSVs, Excel, database tables). Documents are vectorized; tabular data is queried via SQL. The user just asks the question — the system routes it correctly.
Documents are uploaded, classified, and pushed to an OpenAI Vector Store ready for ChatKit retrieval. Structured files (CSV/Excel) hit a Supabase RPC. The custom sql-tool function call validates that every query is SELECT-only or WITH ... SELECT, force-injects LIMIT when missing, and executes via supabase.rpc against a security-definer Postgres function.
Next.js 16 App Router with React 19. OpenAI ChatKit React SDK is mounted in a right-side panel. onClientTool registers a custom 'execute_sql' tool. The tool route (/api/tools/sql) parses the SQL with a regex/tokenizer pass to enforce SELECT-only + LIMIT, then calls Supabase via the service role key (server-only). The vector ingestion route (/api/uploads/documents) classifies file types and routes to either the Vector Store API or the structured pipeline placeholder.
Local-first LaTeX editor with LAN collaboration, an MCP server, and the Tectonic compiler — Overleaf, but everything lives on your machine.
Overtree is a LaTeX editor that runs on your laptop. Files are real folders you can git, back up, or copy. Anyone on your network joins by URL. And — most distinctive — Claude Desktop, ChatGPT Desktop, and Claude Code can connect directly via MCP to read, edit, and compile your projects, with edits appearing live in the editor.
Next.js 16 App Router app with a custom server that hosts both the Yjs WebSocket sync protocol and the MCP server. CodeMirror 6 with stex (LaTeX) syntax. Iron-session for auth. Three MCP transports run simultaneously: stdio for Claude Desktop and Claude Code, HTTP/SSE for ChatGPT Desktop, and Node.js direct for in-process tools.
Next.js 16 + React 19 + CodeMirror 6 frontend bound to a Yjs document via y-codemirror.next. Server-side Yjs WebSocket protocol handler (y-websocket) plus a chokidar file watcher that reflects on-disk changes back into the shared CRDT — meaning AI edits propagate instantly to connected editors. MCP server exposes 12 tools: list_projects, create_project, delete_project, list_files, read_file, write_file, edit_file, delete_file, compile, get_compile_log, get_pdf, get_project_info, list_templates. Tectonic invoked via subprocess; PDFs rendered with pdf.js.
Dual-LLM (Claude + GPT-4o) workbench for the CRISP-DM data-mining lifecycle, with a Python pipeline for prep, modeling, and evaluation.
CRISP-DM is the industry-standard process for data-mining projects (Business Understanding → Data Understanding → Preparation → Modeling → Evaluation → Deployment). This workbench gives an analyst LLM-assisted help at every stage, switching between Claude 3.5 and GPT-4o depending on the task.
Direct Anthropic SDK 0.78 and OpenAI SDK 6.29 — no chat-wrapper. The UI surfaces a model-selector and per-stage prompt templates. A Python pipeline (analyzer.py, processor.py, modeler.py) handles preprocessing, modeling, and evaluation.
Next.js 16 + React 19 frontend with file uploads via Multer. Streaming responses from both providers. Recharts for evaluation visualizations. Python ML stack invoked via subprocess (numpy / pandas implied by processor signatures).
Self-hosted multi-tenant WhatsApp message broker with token-scoped REST API and a read-only monitoring dashboard.
Instead of paying a third-party WhatsApp gateway per agent, this is a single self-hosted broker that any number of internal projects (CRMs, agents, automation flows) can talk to. Each project gets its own token; some projects can read replies, others only send. The dashboard monitors all of it in one place.
Two-service pnpm workspace: an Express server that talks WhatsApp via Baileys and persists everything to Neon Postgres, and a Next.js 15 dashboard that consumes the gateway's own REST API. Authentication is three-header: master token, project token, project name.
Express + Baileys server with rate-limiting (1 send/sec). Sessions are auto-created per phone+project; subsequent sends reuse the session unless explicitly forced fresh. The /messages/session/:id/unread endpoint marks-as-read on the same call — guaranteeing exactly-once inbound delivery to subscribed agents. SSL is auto-detected based on the Postgres host (Railway internal vs public TCP proxy). Persisted Baileys session lives in a Railway volume for reconnect-after-restart.
Photo library organizer with a swipe-deck UI, month bucketing, and persistent progress tracking.
Swipe Fotos lets you organize your photo library by swiping through it month by month. Progress is saved, so you can stop and resume. The UI is intentionally minimal — one photo at a time, two gestures, nothing else.
Lean SwiftUI MVVM. PhotoLibraryService wraps PHAsset enumeration + permissions. ProgressStore persists per-month decisions to Application Support. Three view models (SwipeDeck, AlbumList, MonthBrowser) keep responsibilities tight.
PermissionView gates the rest of the app on Photos.framework authorization. SwipeDeckView is a custom gesture-driven card stack. Month bucketing uses a separate MonthBrowser + MonthBucket model so the UI doesn't fight the data model.
Distributable role-aware tournament scoring system: Next.js web + Express server + Electron desktop, single binary.
Run a karate tournament without a cloud account. Superadmins set up categories, competitors, areas, and seeding from one screen. Referees sign in with their assigned area and start scoring. The audience scoreboard updates live in a separate window. Everything works offline, on a laptop, in a gym with no Wi-Fi.
Three apps + one shared core package. The core is pure logic (no React, no DOM) so it can be reused. The server is Express with JWT signed RS256 from a keypair generated on first launch. The Electron wrapper spawns the server in-process on a random localhost port and serves the Next.js static export from the same origin.
Turbo monorepo. apps/web (Next.js 15 App Router + Tailwind), apps/server (Express + JWT RS256 + bcrypt + admin panel), apps/desktop (Electron wrapper + electron-builder). packages/core holds typed domain logic (bracket seeding, area distribution, tiebreakers). Tokens are renewed silently after 20h of a 24h TTL. Cross-window state syncs via BroadcastChannel + localStorage. Data + RSA keys + activity log persist under ~/.karate-tournament/.
End-to-end encrypted iOS chat client built on the Signal protocol — LibSignal, Network.framework, Keychain, APNs.
Smoke Signals is an iOS chat client built on the same protocol Signal Messenger uses. Messages are encrypted on your device and decrypted on the recipient's — never readable by any server. The whole networking stack is built on Apple's own Network.framework with WebSocket; identity keys live in the Keychain.
LibSignalClient v0.75 + a git submodule of signal-protocol-c. SignalClient singleton wraps session setup, encrypt, and decrypt. ChatViewModel orchestrates the receive loop and message queue. WebSocketClient manages NWConnection lifecycle, token auth headers, and async receive polling. PushManager handles APNs device registration.
C FFI integration for signal-protocol-c (largest project in the portfolio by file count and complexity). Network.framework via custom WebSocketClient (NWConnection + Combine publishers). Identity, prekeys, and session state Keychain-persisted. UI tests + unit tests present.
Internal tools, prototypes, agents, and enterprise pieces. Each one shipped, demo'd, or used. Scroll to scan.
Multi-channel AI sales agent — Telegram + WhatsApp, OpenAI tool-calling, scheduled reminders.
Wholesale-channel variant of Nexora — bulk orders, tiered pricing, B2B workflows.
Competitive-intel ETL — Puppeteer + Cheerio scrapers feeding pricing pipelines.
Tabular data ingestion + visualization — CSV/Excel pipeline with worker threads (Comlink).
Type-safe full-stack supplier agent — tRPC + Supabase + WhatsApp ingestion.
WhatsApp agent that fetches context from OneDrive / Google Drive on demand.
Monorepo scaffold (pnpm + Vitest + Prisma) for a restaurant tooling app.
Cafeteria point-of-sale — workspaces (server / client / shared).
Two-app Turbo monorepo — menu + admin frontends sharing a workspace package.
Promissory-note management web app.
Static event/landing site with multi-page structure.
Batch processing utility scaffold.
Exchange / barter prototype.
Quote-builder UI for the Nexora sales pipeline.
Linear algebra / numerical experiment.
Food / nutrition recommendation prototype.
Research-interface prototype for a UX study.
Admin dashboard reference.
Thermodynamics / educational tool.
Bridge between Microsip ERP and downstream systems.
Agricultural rewards / loyalty B2C iOS prototype with Firebase hooks.
Nutrition tracker iOS prototype with quotes/agent UI.
Auth-gated SwiftUI app with global state and Keychain credentials.
Food delivery / restaurant ordering iOS prototype.
Multi-channel sales agent base scaffold — Telegram + Twilio + Postgres.
Executive assistant — Google Calendar + Gmail + Contacts + Twilio.
Multi-tool agent with Perplexity, Gmail, WhatsApp, and inventory APIs.
WhatsApp support flow built on bot-whatsapp / Baileys.
Hiring, collaborating, or just curious? I read everything.