Flavio Espinoza

A FULL PRODUCTION Solana DeFi trading system I designed, built, and deployed end to end for a private client, solo, with AI as a force multiplier: a sharper blade in a hand that still has to know where to swing. Live on Google Cloud today: autonomous bots watch the market trend and, on a flip, open and close leveraged Kamino JLP/USDC Multiply positions on chain, unattended and 24/7 -- every private key sealed inside a Turnkey signing vault the bots can ask but never hold. 1,064 automated tests green, plus a Playwright end-to-end suite that drives the live dashboard.

1. A.Wield AI the way most developers still have not learned to -- as a force multiplier under tight direction, scoping and reviewing like an eng lead over a team of ICs, to ship production systems solo that would normally take a team; every architecture and correctness call my own.
2. B.Own the whole stack in production -- a headless Node/ESM TypeScript engine on a hardened Google Cloud VM (systemd-supervised, secrets injected from Secret Manager at process start, test-gated stamped deploys) and a Next.js / React / Tailwind operator dashboard on Cloud Run, coupled only through MongoDB Atlas so one person can hold the whole system in his head.
3. C.Custody by construction -- every bot mints its own wallet inside a Turnkey signing vault; a policy-gated non-root signer can sign a Kamino trade and nothing else (proven live: it signed a real Multiply, then refused a rogue transfer from the same code path), and withdrawals can only land on the client's hard-coded wallet.
4. D.Reverse-engineered Kamino's 16-instruction, ~48-account Multiply transaction from real transactions with no SDK -- Anchor discriminators verified 10/10, accounts re-derived from first principles -- and proved the full signed write-path (open, close, swap) on mainnet: build, simulate as a hard gate, sign, submit, confirm. Even the leverage limits are proven against the chain, not the docs: 1x and 6x rejected by Kamino's own program, 2x-5x shipped.
5. E.Everything on-chain, no SDKs -- Kamino, Jupiter, Pyth, and Helius decoded from raw account bytes (Kamino's own SDK returns malformed constants and is banned), the engine building its own JLP/USDC candles directly from on-chain reads every minute, and borrow APR, JLP yield, and LTV computed from numbers it tracks itself, validated against live chain state.
6. F.Engineered the trade path for correctness under races -- an in-process signal bus (never the database) as the only trigger, an atomic compare-and-set that makes "never double-open" real, monotonic idempotency by candle, boot-time crash recovery, and a three-axis risk watcher (price / LTV / borrow-carry) proven live: the stop fired at a 0.1% trigger on a real position.
7. G.Built the trend engine as one shared math core feeding both the historical backtester and the live Binance.US signal feed, proven byte-identical over the full SOL/USDC lifetime (7,625 candles, 474 flips, zero drift) -- then backtested 84 leveraged positions with real soft-liquidation simulation before real money moved.
8. H.Own the client relationship end to end -- scope, build, deploy, handover: the client operates the live system today through his own Google login, funds bots from his own Ledger, and pays invoices in USDC on Solana. Money was the last thing wired, gated behind green backtests and a funding gate.

Model-agnostic AI voice interface: one audio pipe where the AI at the seam is swappable. I use Gemini for research, Claude for coding, ChatGPT for brainstorming -- none of them had hands-free voice I could actually use, so I built one platform that gives me all three.

1. A.Built a model-agnostic AI voice platform -- one audio pipeline (Silero VAD, Deepgram STT, streaming TTS) with the AI at the seam deliberately swappable; v1 runs the Claude Agent SDK (full CLI toolset), Phase 2 plugs in Gemini for research and ChatGPT for brainstorming behind the same pipe.
2. B.Killed my own first design. v1 was Python/FastAPI middleware that quietly neutered Claude -- three tools, a system prompt it ignored, hallucinated timestamps with no shell. Deleted the middleware and ran the Claude Agent SDK directly, archiving the Python backend as a tombstone. Control -> variant -> ship the winner.
3. C.Owned the full stack solo -- React/Vite/TypeScript front end (AudioWorklet 16kHz PCM capture, streamed reply bubbles, live karaoke highlight) and a Node/TypeScript WebSocket backend; same React/TS/Node + Anthropic Claude API stack production teams ship on.
4. D.Built a real-time voice loop -- server-side Silero VAD (energy fallback + pre-roll so the first word is never clipped), Deepgram nova-3 streaming STT with keyterm prompting, and a streaming Aura-2 TTS pipeline that synthesizes per sentence, strips code from the spoken path, paces paragraphs, and resumes from interruptions.
5. E.Instrumented its own spend -- live context-token indicator and a model-fallback cost alert that fires the moment the SDK returns a cheaper model than requested; dual-format (JSON + Markdown) chat persistence with full-text search.

The other side of the same coin as Sol Bot: there I wield frontier models to build, here I help sharpen them. Across six contracts (one active, five completed) I A/B evaluate frontier coding agents on real production codebases and write the rubrics that grade them -- the human-preference signal that tunes the next generation of models.

1. A.A/B evaluate coding agents head-to-head on real-world open-source repositories -- I run the same engineering task through two agents, then produce a structured preference judgment across task success, instruction following, code quality, and thoroughness.
2. B.Author the tasks themselves -- the debugging and feature-development scenarios used in these evaluations, including the acceptance criteria and the specific failure modes each task is designed to surface.
3. C.Document agent behavior against a defined taxonomy -- every finding supported by verbatim evidence pulled from the session record, never a paraphrase.
4. D.Analyze full agent session transcripts to reconstruct what an agent did, in what order, and why -- including behavior that never appears in the agent's own summary of its work.
5. E.Deliver written evaluations against a platform-reviewed quality bar, under confidentiality and originality requirements.

Skills: Large Language Models (LLM), LLM Evaluation, Prompt Engineering, Code Review, Debugging, Software Testing, Rubric Design, Data Annotation, Artificial Intelligence (AI), Technical Writing, TypeScript, Python

Frontier-agent evaluation -- the sharpening side of the same craft as Mercor. I author verifiable coding tasks for the Terminus benchmark: each a self-contained challenge with a deterministic oracle solution, a Docker environment, and behavior-based tests, calibrated against both the Anthropic (Claude) and OpenAI (GPT-5) frontier agents so one task teaches and measures both model families at once.

1. A.Design adversarial evaluation tasks calibrated to a target difficulty band -- scenarios engineered so frontier models fail two to three of five attempts: hard enough to expose a real capability gap, never unsolvable.
2. B.Run head-to-head evaluations of competing frontier models on self-authored scenarios, producing structured comparative judgments rather than pass/fail scoring.
3. C.Author the rubrics and the five-test suite backing each scenario, so every evaluation is reproducible and defensible against a fixed standard.
4. D.Passed an LLM-as-a-judge quality gate on every submitted evaluation -- two returned as exemplary.
5. E.Worked under confidentiality and originality requirements -- every scenario and rubric written from scratch.

Skills: Large Language Models (LLM), Prompt Engineering, Red Teaming, Adversarial Machine Learning, LLM Evaluation, Rubric Design, Benchmarking, Reinforcement Learning from Human Feedback (RLHF), Artificial Intelligence (AI), Technical Writing, Quality Assurance

Bless Network (formerly Blockless) -- seed-funded (~$8M: a $3M pre-seed and a $5M seed), ~12-person decentralized-compute startup. The world's first shared computer, where everyday devices contribute idle browser compute for token rewards. Growth was the product; I own the user-facing growth surface end to end, with no spec, just conversations with our founders and CTO.

1. A.My Chief Technology Officer directed me to use AI to start coding -- my first time. I used ChatGPT to figure everything out (May 2024), and it is where I went from never having used AI to running it as daily core infrastructure.
2. B.Replaced the old email/password/verify signup with a one-click Web3Auth single sign-on (OIDC) -- Google, GitHub, and passwordless email, each deriving a self-custodial Solana wallet and authenticating by challenge-response signature instead of a password. The marketing lead, tracking MailChimp signups against the prior six months, reported completed signups up ~70% and abandonment down ~45% (team-reported, not instrumented).
3. C.Compounded an underperforming referral program (a 10% bonus already in place) by building stacked, OAuth-verified social and quiz boosts on top -- X +5%, Discord +5%, quiz +5% -- summed into one live "Total Boost" to drive virality. The founders reported engagement up ~45% (team-reported, not instrumented).
4. D.Fought the X/Twitter OAuth integration to completion against an API mid-rename from twitter.com to x.com with badly out-of-date docs -- a moving-target integration with no clean answer, shipped by iterating until it worked.

Overclock Labs (Akash Network) -- a seed- and token-funded decentralized cloud marketplace on Cosmos, ~20 people. On a three-person, fully-remote team I proposed the stack and owned the front end, the Node (Fastify mutual-TLS) proxy, the in-browser wallet and certificate crypto, and the four-stage CI/CD pipeline behind the Akash Console -- turning a nine-step command-line deploy into a web app a developer could actually finish.

1. A.Turned a nine-step blockchain deploy protocol into a guided, finishable flow -- from template to running workload -- hiding wallet signing, on-chain certificates, bid selection, and lease creation behind a usable UI.
2. B.Proposed the stack and built the multi-step (5-step) SDL deployment wizard (React + create-react-app, Formik validation) with an 18-plus template marketplace of pre-validated node configs pulled via the GitHub API.
3. C.Designed the Fastify mutual-TLS proxy and WebSocket real-time monitoring -- streaming logs, Kubernetes events, lease status, and an xterm shell back from 100-plus providers, with throttled rendering tuned for continuous streams.
4. D.Built the four-stage GitHub Actions CI/CD pipeline -- auto-versioning, multi-arch Docker builds, staging, and approval-gated production.

WebShield -- a seed-stage healthcare-identity startup (~7 people; seed led by New Enterprise Associates, with a milestone-based convertible note up to $10M) building a person-centric healthcare authorization and consent network. As the sole front-end engineer, I owned the authentication layer and the Node API server behind Exemplar, the app that demonstrated the product to customers and investors.

1. A.Built a production single sign-on (OpenID Connect) layer from scratch, implemented directly from the OAuth 2.0 / OIDC spec on a Koa/Node backend -- the authorization-code flow, JWT signature verification, and state/nonce replay/CSRF protection by hand -- because no off-the-shelf module existed for our stack.
2. B.Led the team's pivot off a stalled enterprise-federation effort (PingFederate) to Okta, clearing the configuration bottleneck and freeing the CTO to focus on the core network.
3. C.Designed a contract-first "mock network" -- a GraphQL resolved_person + trust_summary projection served as fixtures -- that let the entire product ship and demo months ahead of the Go backend; going live to production was a single endpoint-URL swap.
4. D.Owned both directions of the network API: publishing new people and organizations into it (ingest) and querying resolved identities back out (discovery + trust query), all behind that one swappable contract.

A professional crypto trading terminal where the chart IS the interface -- chart-as-order-entry, Fibonacci batch ordering, and a from-scratch indicator library. Same client as eScanner.

1. A.Built the chart itself into the order-entry surface -- a custom D3.js v4 candlestick engine (reworked from react-stockcharts) where open orders are draggable lines on the price chart.
2. B.Built drag-to-modify orders -- dragging an order line triggers an atomic, fully async cancel-and-replace: cancel, wait for escrowed funds to release, recalculate the amount while preserving total cost, then place the new limit order.
3. C.Built Fibonacci batch ordering with curve-based "paradigm" distributions -- draw a fib range and deploy 10+ weighted limit orders in one action, front-loading the deepest rungs to cover a spread.
4. D.Built the real-time Node.js + Express + Socket.IO backend on CCXT's unified exchange layer, with live WebSocket order/balance updates and a D3.js depth chart; shipped in versions (DAX -> Bittrex + HitBTC -> HitBTC). This project later won me the Sol Bot commission.

A real-time cryptocurrency market scanner I built solo for a private trading client -- live-streaming an entire exchange's markets, aggregating them in Elasticsearch, and surfacing the moves worth trading through fast, filterable candlestick views. Same client as Street Fighter.

1. A.Built a real-time crypto market scanner end to end (sole developer) -- live exchange data over Socket.IO, Elasticsearch time-series aggregation, and interactive D3.js / React-Stockcharts candlesticks.
2. B.Koa.js API on an 8-instance PM2 cluster behind Nginx with SSL and ip_hash sticky-session load balancing across 5 Socket.IO upstreams.
3. C.Streamed HitBTC market data via CCXT into OHLCV candle aggregations with configurable intervals and percent-change / volume filters, watchlists, and ignore-lists.
4. D.React / Redux SPA (50+ components) with JWT / Passport auth, Stripe subscriptions, and SendGrid email.

Swim AI (now Nstream) -- a seed-stage edge-computing startup building a real-time streaming and IoT (Internet of Things) analytics platform for device tracking and monitoring; a tight core R&D team of fewer than 15 in San Jose during my tenure. It went on to raise a $10M Series B (ARM, Cambridge Innovation Capital) after I left.

1. A.Designed and developed a web map application on the FLUX pattern with unidirectional IoT data flow.
2. B.Augmented human decision-making with the most accurate, relevant real-time and contextual data -- turning live device data into operational decisions.
3. C.Delivered projects for the San Francisco Transit Authority (live bus tracking), Palo Alto (traffic-light monitoring), the City of Chicago (transformer and meter locations and power consumption), and Boston (automated street-light control). Built with React, the Google Maps API, and Swim APIs; deployed on AWS.

SolarCity -- a NASDAQ-listed (SCTY) residential-solar company of ~15,000–19,000 employees, financed by corporate debt and tax-equity rather than VC rounds, and acquired by Tesla in 2016 (~$2.6B). I was a Lead Full-Stack Engineer on the internal software team that built the real-time installation-analytics platform.

1. A.Led development of a real-time data analytics platform (Python, Django, Angular) for high-volume solar-installation metrics.
2. B.Architected a Django REST API serving real-time analytics to an Angular front end with D3.js visualizations.
3. C.Integrated Elasticsearch for full-text search and analytics across installation records and customer data.
4. D.Optimized MS SQL Server queries, cutting dashboard load times from 40+ seconds to under 3.

Vivint Solar -- A Blackstone private-equity-backed residential solar company founded in 2011 as a Vivint Inc. spin-off (bypassing traditional VC series rounds). I joined as the 6th engineer on a lean core development team that rapidly scaled to 45 engineers over 14 months. In October 2014, the company launched its IPO on the NYSE (VSLR) at a baseline market capitalization of $1.5 billion ($16.00/share). Vivint Solar was later acquired in October 2020 for $3.2 billion by Sunrun, which trades on the NASDAQ (RUN).

1. A.Led a 3-person engineering team building Mercury, Vivint Solar's real-time sales-and-installation analytics platform -- a key source of the sales-and-revenue analytics and presentations used in the company's 2014 NYSE IPO due diligence.
2. B.Engineered an Angular pivot dashboard to replace static HTML readouts -- letting stakeholders instantly slice-and-dice installation metrics, sun-hour distributions, and sales-rep performance in real time.
3. C.Supported macro-filtering (state, system size, module count), account-level drill-downs, and instant CSV export without interface degradation.
4. D.Built the authentication layer and the Node API layer that hooked into a new near-real-time Elasticsearch indexed data store -- our backend team stood up that store, ingesting relational rows from SQL databases and Salesforce via the Elasticsearch JDBC River, replacing a legacy daily reporting job that took over an hour. Our APIs were what tied into it and powered the slice-and-dice.