Juanfe

Available · 2026

Juan FelipeZepeda.

AI & Product Engineer

I build end-to-end AI-native products — native iOS, server APIs, agentic systems, and the infrastructure that ties them together.

I ship complete platforms, not slide decks.

View workContact
  • 5+Production platforms shipped
  • 3AI agents in production
  • 10Featured projects
  • 40+Total projects in portfolio
iOS · Apple
Swift
OpenAI
Anthropic Claude
TypeScript
Next.js
React
Node.js
PostgreSQL
WhatsApp API
Shopify
Vercel

Selected work

10 featured · 38 total

Live demo

Yantissimo Platform

Tire & Wheel Distribution — Operations, Sales, Mobile & Storefront

Real Enterprise ExperienceproductionMay 20264 surfaces · ~800+ source files · 24+ ERP modules · 60 audit tests · daily production use

The operational backbone of an entire automotive distribution business.

Yantissimo Platform is the custom enterprise ERP I built for Yantissimo, 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.

Used by
Internal staff across audit, sales, service, and admin teams; wholesale clients via portal; retail customers via the iOS app and the storefront.
  • Replaces a stack of spreadsheets, Microsip exports, and ad-hoc tools with one daily-used operational system.
  • Daily audit module reads Microsip data, validates technician/vendor performance, lets admins reassign labor (MO) and justify exceptions — with a soft-block before end-of-day close.
  • Live productivity dashboards for vendors and technicians; PDFs for quotes and post-service checks generated in-app.
  • Real-time collaboration via Socket.io — multiple team members work the same orders and audits simultaneously.
  • Customer-facing storefront and downstream apps share the same backend and data model — one source of truth.
  • Production deployed: ERP and storefront on Vercel with PR-preview CI, backend on Railway, native iOS app on TestFlight, all behind one Postgres.
  • 447 source files in the ERP alone; 24+ feature modules under (protected)/ — auditoría, ventas, suite, mayoreo, ordenes, cotizaciones, calendario, equipo, dashboard, agent, claude, campanas, configuracion, garantias, inventario, reports, ramps, seguimiento, todo, snapshots, administracion, myr, plus a (clientes) portal.
  • Real-time multi-user collaboration via socket.io-client across panels.
  • Auditoría module: Microsip Excel parser (parseAuditoria.js, ~550 LOC), pure-function reassignment helpers (reasigMO.js), context-driven state with patchSession persistence, soft-block end-of-day workflow, 60 tests under tests/auditoria/.
  • PDF generation in-app with jspdf + jspdf-autotable (quotes, post-service checks, invoices).
  • Excel import/export with xlsx; Microsip integration via custom parser bridge.
  • FullCalendar + react-big-calendar + react-date-range for service scheduling and team calendars.
  • Recharts dashboards for vendor + technician productivity KPIs.
  • Material UI + HeroUI + Tailwind 4 — heavy custom component library under src/components/{suite,mayoreo,orders,client,tables,modal,ItemModal}.
  • Express backend: 167 files, 41 routes, Jest + Supertest test coverage, async job queue.
  • Embedded AI agent panel inside the ERP itself (/agent route) plus a /claude route — internal staff get LLM help in-context.
  • PR-preview CI via GitHub Actions on the ERP repo.

ERP YSSM (platform): 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.

Yantissimo Platform (ERP YSSM)Operational ERP — daily-used backbone of the business · 447 source files · 24+ feature modules · 60 audit testsCentralized operations — every team works inside one daily-used system instead of a stack of spreadsheets, exports, and chat threads.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.
Yantissimo Backend (yssm-backend)API + orchestration layer feeding the ERP, iOS app, and storefront · 167 source files · ~7.3k LOC · 41 route modulesOne backend powers every customer-facing surface — no parallel systems for the team to keep in sync.41 modular routes: auth, mobile-app, services, quotes, ventas, dashboard, shopify, scrapper, calendar, formula, qr, cron, liquidaciones, invoices, snapshot, …
Yantissimo ShopHeadless customer-facing storefront · ~116 source files · server components + edge middlewareCustomers find the right tire by vehicle (make / model / year) — no expertise or sales call required.Vehicle search ('Por auto') wired through Wheel-Size API into the Shopify catalog — customers find tires by make / model / year.
Yantissimo iOSNative customer-facing iOS app · 68 Swift files · ~7.1k LOC · 541 LOC of testsNative iOS experience customers expect — fast, polished, and delivered through the App Store / TestFlight.Zero external dependencies — no SPM packages, no CocoaPods.
  • Enterprise ERP
  • Real-time Collaboration
  • Audit Workflow
  • Productivity Dashboards
  • Quote & Invoice Generation
  • Service Scheduling
  • Wholesale + Retail Orders
  • Warranty Tracking
  • Microsip Integration
  • PDF Generation
  • Excel Import/Export
  • Headless Storefront
  • Vehicle Search
  • Embedded AI Agent
  • Client Portal
  • Native Mobile
  • Offline Cache
  • Push Notifications
  • Next.js 16
  • React 18
  • TypeScript
  • Turbopack
  • Tailwind CSS 4
  • Material UI
  • HeroUI
  • FullCalendar
  • react-big-calendar
  • react-dnd
  • Recharts
  • Socket.io
  • jspdf
  • xlsx
  • Swift 5.9
  • SwiftUI
  • Network.framework
  • Keychain
  • APNs
  • Node.js 20
  • Express
  • PostgreSQL
  • MySQL
  • Shopify Admin API
  • Shopify Storefront API
  • OpenAI
  • JWT
  • bcrypt
  • Backblaze B2
  • Google Sheets API
  • Puppeteer
  • Wheel-Size API
  • Vercel
  • Railway
  • Jest
  • Supertest
  • GitHub Actions

Vydas

Health & Fitness

Swift / Apple EcosystemactiveMay 202626 Swift files · 8.3k LOC · 6 tabs · Supabase + Claude Edge

A personal AI coach for diet, training, and recovery.

Vydas 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.

Modern SwiftUI + Supabase + Anthropic Edge Functions.

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.

Used by
Athletes and quantified-self enthusiasts.
  • All your fitness context — diet, workouts, labs, supplements — lives in one place the AI can reason over.
  • Daily timeline view shows what's next without forcing the user to navigate menus.
  • Supplement suggestions are generated by Claude with full dietary and lab context.
  • Card visual style is user-switchable at runtime (shadow / border / flat).
  • Six-tab SwiftUI layout: Diet · Exercises · AI · Schedule · Profile · Supplements.
  • MVVM with environment-driven dependency injection (\.repository) for testable views.
  • Theme tokens abstracted into Tokens / F / CardStyle — runtime-switchable card visual style.
  • Supabase backend with HealthKit-synced metrics (daily_energy, exercise_minutes, HRV, weight).
  • Anthropic Edge Function (functions/suggest_supplements) for dietary context-aware suggestions.
  • Bundle id com.zepedajuanfe.Fitness; iOS 18 deployment target; Swift 5.

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.

  • AI Coaching
  • Health Tracking
  • Macro Logging
  • Lab Report Analysis
  • Supplement Suggestions
  • Swift 5
  • SwiftUI
  • iOS 18
  • Supabase
  • Anthropic Claude
  • Edge Functions
  • HealthKit
Live demo

Kiosko Logistics

Logistics & Fleet Operations

Web EngineeringactiveMay 2026Next.js 15 + Python VRP suite · ~400 stores · 8-route bundled demo

Full VRP stack — solver, visualizer, and experiment lab — for a convenience-store distribution network.

Kiosko Logistics solves last-mile fleet routing for a ~400-store retail network. A Python backend implements five classical VRP heuristics (savings, sweep, Fisher–Jaikumar, granular tabu, genetic) with configurable capacity / time-window / distance-weighting constraints; a Next.js dashboard renders the resulting routes on a Leaflet map, animates the run, and exposes a lab for sweep experiments and Pareto fronts across runs.

Python VRP solvers behind a FastAPI server; Next.js 15 + Leaflet + MUI dashboard with a lab for sweeps and Pareto plots.

VRP is NP-hard, so the system is split: an offline Python solver suite that operates on a master plan (Excel/CSV) and produces route JSON, and a thin server that exposes runs/configs/jobs to the dashboard. The dashboard separates the operational view (map + KPIs of the active run) from a lab (elbow plots, clustering, parameter sweeps, Pareto plots).

Used by
Fleet operators, route planners, and logistics analysts.
  • One UI to compare solver outputs side-by-side on the same instance — used to pick the right heuristic per region.
  • Lab dashboard runs parameter sweeps and surfaces the Pareto front across cost, total km, and 8h-rule violations.
  • Pre-computed demo run bundled in the public deploy (8 routes, ~2,300 km) using anonymized store coordinates shifted ~50 m from real positions.
  • Five solver heuristics + cluster-then-solve composition.
  • Pareto and sweep tooling for picking the right heuristic per instance.
  • Live demo bundles a pre-computed run + anonymized stores; Python anonymization script (shifts coords 30–70 m random per store) committed alongside.
  • Lab CSV (5k SKUs × inventory) ships in the public deploy for the volume dashboard.
  • Operates on real master plans (PMO.xlsx) via Excel upload in production.

Python core under algoritmos/ with five solver families (savings, sweep, Fisher–Jaikumar, granular tabu, genetic) and a clustering-then-solve composer; FastAPI server (server/app.py) wraps runs, jobs, configs, plan maestro, and lab endpoints. Frontend is Next.js 15 (React 19, MUI 6, Leaflet, framer-motion) with a Workflow Ribbon orchestrating Rutas → Configurar → Comparar → Lab views. Run results carry a legacy_vrp_output block that the map renders directly.

  • Route Optimization (VRP)
  • Algorithm Comparison
  • Parameter Sweep / Pareto Lab
  • Logistics Visualization
  • Constraint Tuning
  • Next.js 15
  • React 19
  • MUI 6
  • Leaflet
  • Google Maps
  • Python
  • FastAPI
  • VRP heuristics
Live demo

DataKnife (Company Brain)

Enterprise Knowledge & BI

AI EngineeringactiveMay 2026Next.js 16 · OpenAI ChatKit · Supabase RPC

Conversational interface for everything a company knows.

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.

Dual-track ingestion + custom SQL function-call tool with safety guards.

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.

Used by
Business analysts, ops teams, executives querying their own data.
  • One chat answers across documents, spreadsheets, and databases.
  • SQL queries are validated server-side: SELECT-only, LIMIT enforced — safe for non-technical users.
  • OpenAI Vector Store handles document semantics; Supabase handles structured truth.
  • Production-ready ChatKit UI with streaming responses.
  • Custom OpenAI ChatKit tool ('execute_sql') registered via onClientTool.
  • SELECT-only / WITH-only SQL guard with auto LIMIT enforcement.
  • Supabase security-definer Postgres function executed via RPC (service role key, server-side only).
  • Document classification → OpenAI Vector Store with metadata tagging.
  • Spanish-language UI; designed for real Mexican enterprise users.
  • Modern stack: Next.js 16.2 + React 19.2 + Tailwind 4 + shadcn primitives.

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.

  • RAG
  • Hybrid Document + SQL Search
  • Function Calling
  • Conversational BI
  • Data Ingestion
  • Vector Search
  • Next.js 16
  • React 19
  • TypeScript
  • Tailwind CSS 4
  • OpenAI ChatKit
  • OpenAI Vector Store
  • Supabase
  • PostgreSQL
  • shadcn/ui

Overtree

Developer Tools / Writing

Web EngineeringactiveMay 2026Next.js 16 · Yjs CRDTs · MCP server · Tectonic subprocess

Overleaf, but local-first and AI-native.

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.

Yjs CRDT collaboration + MCP server with three transports + Tectonic subprocess.

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.

Used by
Researchers, students, and writers who want local LaTeX with AI.
  • Replaces Overleaf for users who want local-first ownership of their files.
  • Real-time multicursor collaboration on a LAN — no cloud, no per-seat fee.
  • AI clients can edit your LaTeX directly through MCP — edits land live in connected browsers.
  • PDF preview powered by Tectonic, the modern self-contained LaTeX engine.
  • Yjs CRDTs with WebSocket sync (y-codemirror.next + y-websocket + y-protocols).
  • MCP server with 12 tools, three simultaneous transports (stdio, HTTP/SSE, in-process).
  • Chokidar file watcher syncs disk → CRDT → connected editors.
  • Tectonic LaTeX engine invoked via subprocess; pdf.js for in-browser PDF preview.
  • Iron-session auth with per-project name + password.
  • LAN-friendly: prints local IP on startup; firewall guidance documented.
  • Templates: article, beamer, report, letter, ieee, blank.
  • Electron desktop wrapper builds via electron-builder for macOS distribution.

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.

  • Collaborative Editing (CRDTs)
  • Local-First
  • MCP Server
  • LaTeX Compilation
  • AI-Native
  • Desktop App
  • Next.js 16
  • React 19
  • TypeScript
  • Yjs
  • CodeMirror 6
  • MCP SDK
  • Tectonic
  • iron-session
  • Electron
  • Bun
Live demo

CRISP-DM Workbench

Data Science & Analytics

AI EngineeringactiveMay 2026Next.js 16 · Anthropic + OpenAI · Python ML pipeline

An LLM-native workbench for the CRISP-DM data lifecycle.

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.

Dual SDK abstraction with Python compute isolation and streaming.

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.

Used by
Data scientists and analysts running CRISP-DM projects.
  • Analysts move through the full CRISP-DM cycle with model help at each stage.
  • Switch between Claude 3.5 Sonnet and GPT-4o per task — the right model for the right step.
  • Python pipeline (analyzer / processor / modeler) handles compute outside the LLM.
  • Direct Anthropic + OpenAI SDK use, not a wrapper library.
  • Per-stage prompt templates aligned to CRISP-DM phases.
  • Python compute layer for heavy preprocessing and modeling.
  • Streaming-aware UI with Recharts evaluation views.
  • ESM Next.js 16 + React 19 + Tailwind 4.

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).

  • Data Mining (CRISP-DM)
  • Multi-LLM
  • Streaming
  • Python Compute Isolation
  • Evaluation Charts
  • Next.js 16
  • React 19
  • Anthropic SDK
  • OpenAI SDK
  • Python
  • pandas
  • numpy
  • Recharts
  • Multer

WhatsApp Gateway

Messaging Infrastructure

Automation & InfrastructureproductionMay 2026pnpm workspaces · Baileys + Express · Neon Postgres · Railway

WhatsApp infrastructure for an entire fleet of agents.

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.

Token-scoped multi-tenant message broker with exactly-once read.

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.

Used by
Internal agents and CRM systems across the org.
  • Replaces an expensive per-agent WhatsApp BSP with one shared self-hosted gateway.
  • Multi-tenant by design — each agent has scoped credentials and its own session graph.
  • Inbound messages are delivered exactly-once via the unread-poll pattern.
  • Powers downstream agents like yantissimo-crm and kiosko-logistics.
  • Express server + Baileys WhatsApp SDK + Neon Postgres + Next.js 15 dashboard.
  • Three-header auth: X-Master-Token + X-Project-Token + X-Project-Name.
  • --store-replies flag at registration controls whether a project receives inbound.
  • Unread-poll endpoint flips read state on the same call — exactly-once delivery.
  • Auto-detect SSL based on host (Railway internal vs public TCP proxy).
  • Production deployed on Railway with persisted volume for Baileys session recovery.
  • First-class REST API designed for internal agents (curl-friendly).

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.

  • Messaging Infrastructure
  • Multi-tenant API
  • Exactly-Once Delivery
  • Session Management
  • Self-Hosted
  • Node.js
  • Express
  • Baileys
  • PostgreSQL (Neon)
  • Next.js 15
  • pnpm Workspaces
  • TypeScript
  • Railway

Swipe Fotos

Personal Productivity

Swift / Apple EcosystemactiveMay 202618 Swift files · ~2k LOC · MVVM + Photos.framework

Tinder for your camera roll — clear out years of photos, fast.

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.

Clean MVVM + Photos.framework + a custom swipe-deck gesture component.

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.

Used by
Anyone with too many photos.
  • Decide thousands of photos quickly with two gestures.
  • Pick up where you left off — progress per-month is persisted.
  • Browse by album or by month bucket.
  • Photos.framework integration with permission gating.
  • Custom SwipeDeckView with gesture state and physics-feeling deck.
  • ProgressStore serializes per-month decisions to Application Support.
  • Lean MVVM split: 5 views · 4 view models · 4 models · 2 services.

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.

  • Photo Library Organization
  • Gesture-Driven UI
  • Progress Persistence
  • Swift
  • SwiftUI
  • Photos.framework
  • Application Support
  • MVVM
Live demo

Karate Tournament

Sports Tournament Management

Web EngineeringactiveMay 2026Turbo monorepo · 3 apps + 1 core package · ~10k files · 17k LOC

A complete offline tournament platform that ships as a 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.

Turbo monorepo with pure-logic core, JWT RS256 auth, and an Electron wrapper.

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.

Used by
Tournament organizers, referees, and audience displays.
  • One install per laptop runs the entire tournament — no cloud required.
  • Three roles (superadmin / referee / audience) with appropriate access controls.
  • Areas auto-distributed by a balanced bin-packer the superadmin can override.
  • Audience display anonymous and fullscreen-ready.
  • Turbo monorepo with pure-logic shared package (no DOM dependencies).
  • JWT RS256 with keypair generated on first launch.
  • Greedy bin-packer distributes subcategories across competition areas.
  • Electron wrapper bundles server in-process; serves static Next.js from same origin.
  • BroadcastChannel + localStorage sync between admin / private / public windows.
  • Activity log: login attempts, renewals, user mutations, IP addresses.
  • Builds .dmg / .exe (NSIS) / .AppImage installers.

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/.

  • Offline Desktop App
  • Role-Based Access Control
  • Tournament Domain Logic
  • Cross-Platform Distribution
  • Next.js 15
  • React
  • Tailwind CSS
  • Express
  • JWT (RS256)
  • bcrypt
  • Electron
  • electron-builder
  • Turbo
  • TypeScript

Smoke Signals

Secure Communications

Swift / Apple EcosystemprototypeJun 2025127 Swift files · 12.8k LOC · LibSignal + signal-protocol-c

End-to-end encrypted chat done the right way — Signal protocol, Network.framework, Keychain.

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.

Signal protocol over a Network.framework WebSocket, with Combine publishers and APNs.

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.

Used by
Privacy-focused users; reference implementation for secure chat.
  • True end-to-end encryption — server has no plaintext, ever.
  • Apple-native networking (Network.framework + NWConnection) — no third-party WebSocket libraries.
  • Identity material is Keychain-backed and never leaves the device.
  • LibSignalClient v0.75 + signal-protocol-c git submodule (C FFI).
  • Custom WebSocket client built on NWConnection + Combine.
  • Keychain-backed identity, prekeys, and session state.
  • APNs device registration through PushManager.
  • MVVM with ChatViewModel orchestrating session setup, send, and receive.
  • Full UI + unit test coverage scaffolded.

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.

  • End-to-End Encryption
  • Signal Protocol
  • WebSocket Realtime
  • Push Notifications
  • Cryptographic Key Management
  • Swift
  • SwiftUI
  • LibSignalClient
  • signal-protocol-c
  • Network.framework
  • NWConnection
  • Combine
  • Keychain
  • APNs
  • CocoaPods

More projects

  • Nexora Agent2026

    Multi-channel AI sales agent — Telegram + WhatsApp, OpenAI tool-calling, scheduled reminders.

    Node.jsOpenAIPostgreSQLTelegramTwilio
  • Nexora Distribution2025

    Wholesale-channel variant of Nexora — bulk orders, tiered pricing, B2B workflows.

    Node.jsOpenAIPostgreSQL
  • YSSM Scraper2025

    Competitive-intel ETL — Puppeteer + Cheerio scrapers feeding pricing pipelines.

    Node.jsPuppeteerCheeriop-limitPostgreSQL
  • Mati Data2026

    Tabular data ingestion + visualization — CSV/Excel pipeline with worker threads (Comlink).

    Next.js 16React 19Papa ParseRechartsComlink
  • Suppliers Agent2026

    Type-safe full-stack supplier agent — tRPC + Supabase + WhatsApp ingestion.

    Next.jstRPCSupabaseBaileysOpenAIZod
  • OneDrive Retriever2026

    WhatsApp agent that fetches context from OneDrive / Google Drive on demand.

    Node.jsBaileysOpenAIGoogle Auth
  • Restaurant Waster2026

    Monorepo scaffold (pnpm + Vitest + Prisma) for a restaurant tooling app.

    pnpm WorkspacesTypeScriptVitestPrisma
  • Mootie POS2026

    Cafeteria point-of-sale — workspaces (server / client / shared).

    Node.js WorkspacesTypeScript
  • Plick Clone2026

    Two-app Turbo monorepo — menu + admin frontends sharing a workspace package.

    Next.js 15React 19Tailwind 4Turbo
  • Promissory Notes2026

    Promissory-note management web app.

    Next.jsTypeScript
  • Padelón2026

    Static event/landing site with multi-page structure.

    HTML5CSS
  • Batch2025

    Batch processing utility scaffold.

    Node.js
  • Intercambio2025

    Exchange / barter prototype.

    Web
  • Nexora Quoter2025

    Quote-builder UI for the Nexora sales pipeline.

    Web
  • Eigenvalues2025

    Linear algebra / numerical experiment.

    Web
  • Food Healer2025

    Food / nutrition recommendation prototype.

    Web
  • Research Interface2025

    Research-interface prototype for a UX study.

    Web
  • Next.js Dashboard2025

    Admin dashboard reference.

    Next.js
  • Termo Sapiens2025

    Thermodynamics / educational tool.

    Web
  • Microsip Sync2025

    Bridge between Microsip ERP and downstream systems.

    Node.js
  • AFFIN Agro2025

    Agricultural rewards / loyalty B2C iOS prototype with Firebase hooks.

    SwiftUIFirebase
  • NutriGen2025

    Nutrition tracker iOS prototype with quotes/agent UI.

    SwiftUIKeychain
  • Altozano2025

    Auth-gated SwiftUI app with global state and Keychain credentials.

    SwiftUIKeychain
  • Delitec2025

    Food delivery / restaurant ordering iOS prototype.

    SwiftUIMVVM
  • Base AI Agent2026

    Multi-channel sales agent base scaffold — Telegram + Twilio + Postgres.

    Node.jsOpenAITelegramTwilio
  • YARVIS Executive Agent2025

    Executive assistant — Google Calendar + Gmail + Contacts + Twilio.

    Node.jsOpenAIGoogle APIsTelegram
  • Test Agent2025

    Multi-tool agent with Perplexity, Gmail, WhatsApp, and inventory APIs.

    Node.jsOpenAIPerplexityBaileysGoogle APIs
  • Laptop Support Bot2026

    WhatsApp support flow built on bot-whatsapp / Baileys.

    Node.jsBaileysbot-whatsapp

Who’s behind it

I ship end-to-end products — iOS, web, backend, integrations — under one architectural vision. Yantissimo runs three coordinated surfaces; Karate ships as a single Electron binary; the WhatsApp gateway powers an entire fleet of internal agents.

Yantissimo PlatformKarate TournamentWhatsApp Gateway

Function calling with safety guards. Hybrid RAG that routes documents and SQL through one chat. MCP servers exposing local tools to Claude and ChatGPT. Multi-agent sales workflows in production on Telegram and WhatsApp.

DataKnifeCRISP-DM WorkbenchOvertree (MCP)

When the per-seat SaaS bill stops making sense, I build the in-house version. WhatsApp gateway replaces a per-agent BSP. Overtree replaces Overleaf with local files and AI access.

WhatsApp GatewayOvertreeYSSM Backend

Zero-dependency APIClient with 401 refresh retry. Application Support cache hydration. Keychain-backed sessions. Network.framework over WebSocket. MVVM with environment-driven dependency injection.

Yantissimo iOSSmoke SignalsVydas

Backend

Production Express APIs with real test coverage, async jobs, modular middleware.

Node.js 20+ExpressBunFastifyMulterJest + Supertest

Shipped in

  • Yantissimo Backend (167 files / 7.3k LOC, 41 routes)
  • WhatsApp Gateway

Juan Felipe Zepeda

AI & Product Engineer

I am a Mexico-based AI and product engineer who builds complete platforms — front-end, back-end, mobile, agents, and the infrastructure that ties them together. My work spans native iOS (SwiftUI), Next.js, Node.js, real-time systems (Yjs CRDTs, OpenAI Realtime), and AI-native architectures (RAG, function-calling, MCP servers, multi-agent orchestration).

My flagship work 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 also build internal tooling and automation: a self-hosted WhatsApp gateway, an Overleaf-style local-first LaTeX editor with an MCP server, and AI agents handling sales and customer support across Telegram and WhatsApp.

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. The work shows.

Open to senior product / AI engineering roles & high-leverage contract work.

Email me

Contact

Let’s build something.

Open to senior product / AI engineering roles & high-leverage contract work.

ze_zepedajf@outlook.com
GitHub LinkedIn