Ibex Labs
AI infrastructure / Solana / backend systems

Senior backend engineering for production systems.

I'm Alex, a senior backend engineer. I build AI infrastructure, onchain protocols, and the Rust/TypeScript services and ops around real products — from early architecture through scale.

Scaling AI media platform infrastructure for OTOY
Led Render ETH → Solana migration work
Building onchain lending infrastructure for CFi
Backend and distributed systems background (Block/Square, IBM)
What I do
The work I'm strongest at lives between infrastructure, backend systems, and product execution.
AI backend infrastructure and model integration pipelines
Solana programs and onchain protocol integrations
Rust/TypeScript backend services and data pipelines
Production operations, scaling, and hardening
Working products delivered end-to-end

Proof

Shipped work across AI and onchain systems.

AI Infrastructure

AI media platform — scaling infrastructureOTOY logo
Scaling backend infrastructure for OTOY Studio, a node-based canvas for chaining AI image, video, voice, and 3D models. Taking the platform from 50 beta users to 10k.
  • Media pipeline architecture: async job orchestration across FAL inference, Neon Postgres, and Cloudflare R2
  • Streaming FAL→R2 copy via Cloudflare Workers to eliminate Vercel hop and cut copy costs ~98%
  • Job completion reliability: webhook integration, recovery flows, and cron-based retry for durable asset persistence
  • Schema and query hardening for scale: partitioning, capacity planning, and billing system consolidation
Technical details->
  • OTOY Studio is a ReactFlow-based canvas that lets users wire AI models (image, video, voice, 3D via fal.ai) into production pipelines. The backend orchestrates graph execution, async job submission, output persistence, and durable storage on Cloudflare R2.
  • Architected the media pipeline from Vercel serverless to Cloudflare Workers for FAL→R2 asset copy, eliminating the extra Vercel hop and leveraging R2 binding for same-account low-latency writes with ~98% cost reduction.
  • Designed FAL webhook integration to replace fragile serverless polling (subscribe loops killed by Vercel function freezes), with client-side recovery via stale-job sync and cron retry sweeps.
  • Hardening Neon Postgres schema for 200× scale: addressing unbounded JSONB workflow graph storage, workflow version snapshot explosion, timestamp timezone handling, and concurrent billing race conditions.
  • Building real-time notification layer (ElectricSQL or Ably) to replace TanStack Query polling of job status, reducing DB read load at scale.
  • R2 lifecycle and garbage collection policy: retention rules, orphan cleanup, and quota enforcement for a storage model that currently keeps everything indefinitely.

Onchain / Web3

ETH → Solana migrationRender Network logo
Led core Solana protocol and backend work for Render's migration from Ethereum to Solana, including emissions, bridging, rewards, accounting, dashboards, and production operations.
  • Burn-and-mint equilibrium implementation
  • Wormhole bridge relayer and adhoc exchange migration support
  • Reward automation for node operators, migration incentives, and partners
  • Solo through initial protocol, backend, ops, and frontend work end-to-end; hired engineers afterward and helped hand off
Technical details->
  • Implemented Render's burn-and-mint equilibrium model on Solana: scheduled RENDER emissions plus a separate process that listened for completed render jobs and bought/burned Solana RENDER as a function of ETH RNDR spent.
  • Built token bridge flows so users could convert ETH RNDR into Solana RENDER through Wormhole, including incentive mechanics for early migration and support around large CEX migrations.
  • Automated network payment channels: weekly node-operator rewards, monthly upgrade rewards for migration participants, and partner payouts for nodes also doing compute on networks like io.net.
  • Wrote Solana programs in Rust for emissions, BME, bridge-side token movement, tokenized network entities such as render nodes, and releasing multiple reward channels.
  • Built TypeScript servers and cranker jobs for serving/indexing data from Redis/Postgres and orchestrating protocol operations against Solana.
  • Built the Solana-side bridge relayer for redeeming Wormhole VAAs into RENDER.
  • Built Postgres-backed dashboards for node operators and holders to track payments and network stats, plus internal accounting dashboards for movement tracking and reporting.
  • Ran the production stack on Kubernetes with Grafana, Prometheus, Alertmanager, Loki, Tempo, PagerDuty, Vault/bank-vaults secret injection, and Nginx ingress.
Onchain lending infrastructureCFi logo
Building an end-to-end onchain system for agricultural lending: an Anchor protocol, Bridge on/off-ramp integration, worker jobs for ACH-driven state changes, and frontend workflows for dealers and farmers.
  • Role-based lending protocol for institutional and retail lenders subsidizing farmers
  • Onchain loan origination, management, draw tranches, interest accrual, repayment settlement, and vault deposits/withdrawals
  • Bridge (Stripe) on/off-ramp integration plus ECS workers for ACH movement and onchain state advancement
  • Dealer and farmer frontend workflows for repayments and obligation monitoring
Technical details->
  • Anchor protocol for institutional and retail lenders to subsidize farmer financing, with role-based ACLs across lender, dealer, farmer, and protocol operations.
  • Onchain origination and management of loans, including creation of draw tranches as farmers spend against approved financing.
  • Interest accrual on individual draw tranches, with settlement flows covering farmer repayments, lender vault accounting, and dealer-covered farmer interest.
  • Onchain vault flows for lenders depositing into and withdrawing from lending pools.
  • Bridge (Stripe) integration for seamless fiat on/off-ramp flows around protocol activity.
  • ECS worker jobs that listen and poll for ACH fund movement, then advance onchain state and trigger accrual/settlement work.
  • Frontend surfaces for dealers and farmers to execute repayments and monitor outstanding obligations.
Solana products + low-latency backendNation logo
Built across Nation's Solana ecosystem: the core DAO platform, Vellum for distributed document signing, and Caro, a real-time auction engine embedded into Shopify storefronts.
  • Core Solana DAO platform for organizations, funds, voting, and proposals
  • Vellum: DocuSign-like document signing on Solana with GPT-assisted drafting and post-signature actions
  • Caro: real-time auction engine served as an embeddable Shopify widget
  • Full-stack product work across Solana programs, backend services, frontend, and infrastructure
Technical details->
  • Nation core started as a DAO platform on Solana, letting users create organizations, collect funds for causes, vote on proposals, and manage organization workflows.
  • Vellum was a Next.js/Vercel product backed by Supabase for Postgres, realtime sockets, and blob storage, with Solana Rust programs for writing documents onchain and executing post-signature actions.
  • Vellum included GPT-4-assisted document drafting and post-execution actions such as transferring funds after a document was signed.
  • Caro implemented several real-time auction formats as a Shopify widget that could be embedded into storefronts.
  • Caro began as a Rust backend using Actix, with an HFT-like design where each auction was assigned to a node and loaded in memory for low-latency bids/checkouts.
  • The Rust service was load-tested around 500 bid requests/sec on a single Docker instance, then later ported to Deno because the service was effectively I/O-bound and the development loop/tooling were much faster.
  • Moved auction state from in-memory plus async Postgres persistence toward Redis and Lua scripts where atomicity was needed, while preserving similar performance characteristics.

Resume

Full resume

->

Where I'm useful

The technical surface I cover.

Best fit is AI-native products, onchain finance, payments, protocol infrastructure, and any team where backend systems, data pipelines, and product have to work together cleanly.

AI infrastructure
Async job orchestration, media/data pipelines, model integration, streaming storage, and the backend plumbing that makes AI products work at scale.
Solana protocol work
Anchor programs, account models, token flows, migrations, reward systems, and production-grade transaction paths.
Backend systems
TypeScript and Rust services, Postgres, Redis, event-driven pipelines, observability, idempotency, and operational dashboards.
Production hardening
Scale prep, failure modes, schema optimization, monitoring, and the unglamorous work that keeps shipped systems from surprising you.
Full-stack execution
Enough frontend to ship workflows, enough infra to run them, and enough domain context to keep the system coherent.

About

Backend and distributed systems engineer.

Started in backend and distributed systems at various companies, then spent the last four years shipping onchain products on Solana. Now also building AI infrastructure — the same patterns (async orchestration, streaming pipelines, production ops) applied to a different domain.

I fit best with small, serious teams building real products where correctness, reliability, and speed all matter. My goal is to deliver exactly the product required in the simplest, most durable way possible.

Working style

High-agency, technical, product-aware.
High-agency and comfortable with incomplete specs
Async-friendly, but direct when a decision needs to be made
Strongest where backend, infrastructure, product, and ops overlap
Prefer small teams, real ownership, and work that ships

Stack

Built around production systems.

RustTypeScriptGoSolanaAnchorPostgresRedisCloudflare WorkersKubernetesVercelNeonSupabaseGrafanaPrometheus

Contact

Building something where this background fits?

Whether it's AI infrastructure, onchain systems, or backend at scale — send a short note with what you're building and where complexity enters the picture.