AI Integration for Existing Web Applications

Add AI features and MCP discovery to a web app that's already running.

You have a working SaaS, internal product, or web application. Your AI story is "we should probably do something about that." This is the gap I close.

I plug AI features into apps you've already shipped — without forcing a rebuild, without tying you to a specific provider, and without locking you into one model or one framework.

What I build:

• Conversational interfaces — chat, Q&A over your data, multi-turn workflows
• Agent-powered features — task automation, multi-step workflows, function-calling against your existing APIs
• RAG systems — retrieval over your documents, knowledge base, product catalog, or customer data
• MCP server integration — make your app discoverable and transactable by Claude, Cursor, ChatGPT, and any other MCP-compatible AI agent in real time
• Provider-agnostic architecture — switch between Anthropic, OpenAI, or local models without rewriting your application

Stack-flexible: I work with what you've already shipped. TypeScript/Node/Next.js, Python/FastAPI, Rust, even legacy PHP — the AI layer plugs into your stack, not the other way around.

Deliverable: working AI features inside your existing app, live MCP endpoint if you want one, documentation, and a clear path forward you can hand to your team.

Good fit for: SaaS companies, internal tooling teams, agencies, and product teams whose product works but whose AI roadmap is empty, stuck, or stalled at "we built a chatbot demo six months ago."

Modern Web Application Development

Greenfield web apps on the stack that ships fast and stays maintainable.

When you need a new web application built from scratch — a SaaS product, an internal tool, a customer portal, an admin dashboard — I build it on the modern web stack: TypeScript, React, TailwindCSS, TanStack, Next.js or vanilla React, Node or Bun on the backend, PostgreSQL underneath.

What you get:

• Type-safe end to end — TypeScript on frontend and backend, with shared types where it matters
• TanStack Query / Router / Form for state, navigation, and form handling that survives at scale
• TailwindCSS for styling that survives design changes
• Auth, sessions, billing, and admin scaffolding — the boring parts that take six weeks to get right, done in a week
• AI-Driven Development workflow — built with Claude in the loop, which means more delivered per week and tighter feedback between you and the codebase
• Optional MCP layer — every app I ship can expose itself to AI agents on day one, not as an afterthought

Deployment-flexible: ships to Vercel, AWS, your own VPS, or containerized infrastructure — your call.

Deliverable: a working application, a clean codebase, infrastructure-as-code where it matters, and documentation a future developer can read.

Good fit for: founders building a new product, teams replacing a legacy app, agencies looking for fractional engineering capacity, or any business that needs a web app shipped on a stack their team can hire for.

Custom MCP Server Integration

Make your business discoverable by AI agents in real time.

AI assistants are increasingly the first layer people use to research a company. If your services, pricing, and contact info aren't structured and machine-readable at a live endpoint, you're invisible to that layer.

I embed a custom MCP (Model Context Protocol) server directly into your website. Any MCP-compatible AI — Claude, Cursor, custom agents — can connect, query, and get accurate, current answers about who you are and what you offer. No scraping, no stale data, no waiting for a training run.

What you get:

• Public MCP endpoint with your services, FAQ, and knowledge base
• Private admin MCP so you (or your AI assistant) can publish updates without a CMS
• RFC 9728 OAuth discovery so agents find your server automatically
• HTTP Link header + HTML <link rel="mcp"> for self-describing integration

Deliverable: /mcp endpoint + auth + 5-15 tools tuned to your domain.

Good fit for: consultancies, agencies, SaaS companies, anyone whose business info changes often enough that stale search results cost them leads.

Rust/Axum Production Backends

Web applications that ship as a single binary and just run.

I build production web apps in Rust + Axum. One 4MB binary, PostgreSQL, server-rendered HTML with Askama templates, no container orchestrator. Your app runs on a single VPS and stays up.

What you get:

• Server-side rendered app with HTMX or vanilla JS — fast, SEO-friendly, no hydration cost
• Type-safe SQL via SQLx
• Session-based auth (bcrypt, CSRF tokens, session fixation protection)
• Tailwind CSS v4 via Bun for styling
• Cross-compiled from Mac/Linux to any Debian/Ubuntu target

Deliverable: cargo run → production in under a week for most greenfield apps.

Good fit for: founders who want to own their infrastructure, teams leaving Node.js behind, anyone tired of waiting for npm install.

PHP → Rust Migration

Move a legacy PHP application to a Rust backend without losing data or uptime.

I've done this myself: the site you're on is a Rust rewrite of a PHP original, running on the same database, deployed alongside the v1 binary during transition.

What you get:

• Side-by-side deployment (v1 and v2 share the same PostgreSQL, no big-bang migration)
• Route-by-route rewrite so you can switch traffic gradually behind a reverse proxy
• Schema audit and cleanup while I'm in there
• Deployment scripts that replace your PHP-FPM pool without downtime

Deliverable: side-by-side deploy, traffic-switch plan, PHP retirement checklist.

Good fit for: PHP sites that still make money but are getting expensive to maintain, teams that need type safety and modern tooling but can't afford a 6-month rewrite cycle.

Lightweight CRMs & Internal Tools

Owned, fast, minimal internal tools — not SaaS subscriptions.

Most CRMs and internal dashboards are either bloated SaaS platforms or fragile spreadsheet chains. I build focused internal tools you own: customer lists, lead tracking, form submissions, admin dashboards — shipped as a single binary you can run on any server.

What you get:

• Custom data model built around your actual workflow (not someone else's template)
• Simple admin UI with session auth
• CSV import/export
• Full control of data — runs on your infrastructure, your database, no third-party SaaS bills

Deliverable: an opinionated internal tool + the binary + the database schema + the runbook.

Good fit for: solo founders, small teams, anyone paying for CRM features they don't use.

Solo-Scale VPS Deployment Setup

A complete, working deployment pipeline for your Rust app — no Docker, no CI budget required.

You have a Rust app and a VPS. You don't want to set up GitHub Actions, manage a container registry, or learn Kubernetes. I set up the pipeline: build script, deploy script, systemd unit, Nginx config, and TLS. One command from your laptop, live in under two minutes.

What you get:

• scripts/build.sh — cross-compile via cargo-zigbuild + CSS build
• scripts/deploy.sh — scp artifact, restart service
• Systemd unit with auto-restart
• Nginx config with TLS termination and long-cache static asset serving
• Documentation you can hand to the next dev

Deliverable: build + deploy scripts, systemd unit, Nginx config, one-page runbook.

Good fit for: solo developers, side projects, anyone whose CI bill is bigger than their VPS bill.

Secure Agent Architecture & Capability Design

The layer underneath the prompts.

Most "build me an agent" help is about chains, RAG, and prompt engineering. I work on what's underneath: the capability model, the permission graph, and the isolation boundary that determines what your agent can and can't actually do — regardless of what the LLM decides to try.

This is the angle I've been developing in my own agent platform, agwo — security-first orchestration with IPC isolation between the trusted core and the untrusted tool store, a capability-based permission model, and a design where damaging tool calls are impossible by construction rather than by policy.

If you're building an agent where wrong answers are embarrassing but wrong actions are expensive — writes to a database, messages sent to customers, money moved, hardware controlled — the part that needs to be right isn't the prompt. It's the boundary around the prompt.

I can help you:

• Design a capability and permission model that makes dangerous tool calls impossible by construction, not by policy
• Architect tool isolation so a compromised or hallucinating tool store can't reach the orchestrator or the data plane
• Audit your MCP server's auth, scope enforcement, and RFC 9728 discovery — a common weak point in production deployments
• Review agent-to-agent communication boundaries and trust assumptions

Deliverable: capability spec, permission graph, MCP auth design doc, and a written review of high-risk surfaces in your current architecture.

Good fit for: teams building agents that take real actions — writes, messages, transactions, control surfaces. Not a fit for RAG prototypes, chatbot demos, or framework-selection questions.