Open to senior full stack & AI engineering roles

Haroon MukhtarSenior Full Stack Engineer · AI Engineer

I build web platforms, AI agents, RAG applications, and cloud-hosted products. Five years of shipping production systems with TypeScript, React, Node.js, AWS, LLM agents, and retrieval pipelines.

TypeScriptReact / Next.jsNode.js / NestJSAWSLangChainRAG
0+

Years of engineering experience

0

Production platforms shipped end to end

0+

AI agent & RAG systems built

0+

Lighthouse performance score on shipped sites

About

How I work

I'm a Senior Full Stack Engineer based in Islamabad, Pakistan, with five years of experience building production software. I've worked on no-code website builders, enterprise business platforms, virtual classrooms, e-commerce frontends, and lately AI products.

Most of that work sits in the TypeScript ecosystem: React and Next.js on the frontend, Node.js and NestJS on the backend, with PostgreSQL, AWS, and CI/CD pipelines underneath. The parts I pay closest attention to are architecture that stays maintainable, performance budgets, accessibility, and whether the next person to open the codebase can find their way around it.

Over the last few years the work has shifted toward AI engineering: LLM-powered assistants, agentic workflows, retrieval-augmented generation, tool-using agents, and autonomous pipelines running in production. That overlap between product engineering and AI systems is where I do my best work.

Product engineering, end to end

I own features across the full stack: the UI and its design details, the APIs and data models behind it, and the pipeline that deploys the whole thing.

Modular systems

Website builders, enterprise operations platforms, collaborative tools. All of them needed modules with clear boundaries, so the codebase stays workable as the product grows.

AI as an engineering discipline

I treat LLM applications like production software. Agent orchestration, retrieval pipelines, memory, and evals get the same attention as the rest of the stack.

Expertise

What I build

Four areas of work. Each comes down to the same thing: systems that hold up once real users and real data reach them.

Full Stack Product Engineering

Product systems across the whole stack, from frontends built against a performance budget to backend services split into modules.

  • React, Next.js, Node.js, NestJS, TypeScript
  • Scalable architecture & modular systems
  • Complex dashboards & internal tools
  • Performance-focused frontend systems
  • Backend APIs & service design

AI Agents & LLM Applications

Core focus

AI systems that run in production: agents that reason, call tools, retrieve context, and hold memory, built with the same rigor as any other backend.

  • AI agents & agentic workflows
  • Retrieval-augmented generation (RAG)
  • LangChain / LlamaIndex-style architectures
  • Tool-using agents & ReAct orchestration
  • Portfolio & financial assistants
  • Context-aware streaming chat systems
  • Prompt orchestration & AI automation pipelines

Cloud & Infrastructure

Automated, observable cloud deployments and hosting, with the release steps kept in code.

  • AWS deployments & hosting architecture
  • CI/CD pipelines & Docker
  • Domain & SSL configuration automation
  • Edge gateways & single sign-on on Cloudflare Workers
  • Scalable publishing & deployment workflows
  • Performance optimization in production

Product Architecture & Collaboration

Multi-user products with real-time collaboration, on modular foundations that stay maintainable.

  • Real-time collaboration & multi-user systems
  • Form builders & CMS / no-code systems
  • Modular, monorepo-based architecture
  • Maintainable engineering systems

Featured Projects

Selected case studies

Systems I designed and built for employers, clients and my own use.

Flagship · Multi-Agent Platform

Agent Builder

Research agents for a financial research firm

A TypeScript monorepo of research agents: a Mastra agent service, a NestJS gateway and a React front end. An earnings monitor pulls live data via MCP (Aiera, Gmail, Drive, Calendar), writes digests, updates calendars and leaves the emails as drafts. A transcript pipeline turns recorded expert calls into analyst anecdotes in the firm's house style, and a research chat agent answers from shared and private knowledge bases with semantic memory recall. LLMs only make bounded judgment calls, structured in and structured out; state, dedup, and templating stay deterministic in code.

TypeScriptMastraClaudeVercel AI SDKMCPNestJSReactlibSQLDocker
Why I built it →

Challenge

During earnings season, analysts monitor live events, cross-reference internal reports, and draft daily digests by hand. After every expert call someone also writes the call up as anecdotes in the house style. The tools and data sources involved do not talk to each other.

Solution

A scheduled sweep pulls the earnings watchlist over MCP, dedupes events with single-purpose LLM calls, and sends small research agents for consensus and price anchors. Code then builds the digest, updates Google Calendar and creates Gmail drafts. When a Zoom call ends, a webhook queues a job and a background worker runs a 5-pass anecdote pipeline: KPI selection, synthesis, a lint and rewrite pass, a completeness check, and sentiment. The result lands as a .docx attached to a Gmail draft, and analysts review it in a queue.

Impact

Digests, calendar updates and call write-ups arrive as drafts for an analyst to check and send. The manual part of earnings season shrinks to review.

Core features

  • Earnings & Events Monitor pulling live data via MCP, run per user with their own Google connection
  • Zoom transcripts turned into analyst anecdotes by a 5-pass LLM pipeline, delivered as .docx drafts
  • Anecdote channels with their own KPIs, tone, recipients and call matchers, plus a review queue
  • Editor agent that separates one-off edits from lasting house rules, which a person approves
  • Research chat agent with semantic memory recall, working memory and tool approval prompts
  • Shared and private knowledge bases built from PDF and markdown, embedded locally
  • Monitoring with traces, health checks, deduplicated alerts, cost estimates and an eval gate
  • Custom React front end for research workflows and real-time interaction

Engineering highlights

  • Mastra agent framework orchestrating LLM reasoning with deterministic TypeScript code
  • Base prompts never change, so they stay cached; learned house rules are appended after them
  • MCP tools are mapped to fixed names, so the model never sees each server's raw tool names
  • Zoom webhooks are verified with a constant-time signature check and answered at once, with the slow work queued
  • Per-user Google OAuth tokens encrypted at rest with AES-256-GCM
Platform · Identity & Access

Centralised Auth Service

One sign-in and one access policy for a company's internal apps

A Cloudflare Worker gateway signs people in once, with a magic link or a 6-digit code, and sits in front of every internal app. On each request it checks the session and whether the person may use that app, then forwards a short-lived signed identity. An admin portal compiles users, groups and grants into a versioned SQLite policy file, and an SDK lets each app answer detailed permission questions locally from that file. It is deployed, with four apps behind it.

TypeScriptCloudflare WorkersHonoWorkers KVNestJSSQLiteDrizzleReactAWSGitHub Actions
Why I built it →

Challenge

Each app ran its own login and its own permission tables. One used database roles, one used shared API keys and one had no auth at all, so nobody could grant, review or revoke access in one place.

Solution

Sign-in happens on a single login host, and a one-time handoff code tied to the browser that started it carries the session back to the app's own domain. On every request the gateway mints a 5-minute ES256 JWT and proxies to the origin through Cloudflare Tunnels, behind a WAF rule that admits only the Worker. Apps verify the token against a static JWKS and ask the SDK what the person may do; it returns the limits that apply, and the app applies them to its own queries. Services use app tokens: deploy tokens send an app's capability list from CI, and runtime tokens let a running app poll for new policy versions.

Impact

Access to four internal apps is granted and revoked in one place, and each app checks permissions locally without calling the gateway.

Core features

  • Passwordless cross-domain sign-in with a magic link or a one-time code
  • Edge gateway with per-host routes, API path routing and public webhook lanes
  • Admin portal for users, groups, grants with include and exclude limits, publishing and version history
  • Policy compiler that turns the admin database into a versioned SQLite file
  • SDK with Express middleware and an edge-safe token verifier
  • App tokens for deploy pipelines and running services, stored only as SHA-256 hashes
  • Capability sync from CI that is safe to run repeatedly

Engineering highlights

  • Unknown addresses get a sign-in nobody can complete, with the same storage writes and timing as a real account, so accounts can't be enumerated
  • The proxy overwrites the identity header and strips gateway cookies in every spelling the parser accepts
  • Apps deny everything until a policy loads, then refresh it with ETag polling, backoff, a hash check and a version floor
  • A deploy can't widen access: removed capabilities stay with a warning, and limit changes wait for an admin to publish
  • Policy versions are write-once in S3, and deploys authenticate with GitHub OIDC instead of stored AWS keys
  • Requesting a sign-in email went from 6–8 s to under 2 s after parallelising KV calls and deferring writes
AI Agent · Desktop App

Autonomous Browsing

Browser automation agent that saves its runs as routines

An Electron app for an internal operations team. You type a goal and Claude drives a real Chrome to reach it, one action at a time. A finished run can be saved as a routine that replays later without calling the model. When a site changes, the routine proposes a repair or stops and asks a person.

ElectronTypeScriptReactPlaywrightClaudeSQLiteChrome Extensions
Why I built it →

Challenge

Web chores needed a person watching, and scripted automations broke whenever a site changed its layout. The team wanted runs that finish without supervision and that they can trust afterwards.

Solution

The app starts its own Chrome on a dedicated profile and attaches with Playwright over CDP. A second backend drives the user's everyday Chrome through an extension and a native-messaging relay. Each step sends the model a filtered DOM and a compressed screenshot, and the model picks the next action through a tool call. Saved routines are JSON steps with parameters, stored in SQLite. Replay makes no model calls while it works; a broken step goes through selector ranking, a check that the page reacted, an LLM repair and finally a human hold.

Impact

Repetitive web checks run unattended, and a routine that worked once keeps working after a site changes, with a person approving every repair.

Core features

  • Goal runs that hand off to a person at a CAPTCHA, login or bot wall
  • Routines with parameters, assert steps, and revision history with undo
  • Proposed repairs wait in a review queue and are never written back silently
  • Run queue and resume from failure that never repeats a step that placed an order
  • Per-site memory of page landmarks that users can inspect and clear
  • Run history with a token and cost meter, and a health view per routine
  • Export and import with secret detection and redaction

Engineering highlights

  • Both browser backends inject the same in-page engine, so their safety checks can't drift apart
  • Page content reaches the model inside a fresh random fence each turn, as a prompt-injection defence
  • The DOM is cut to an interactive skeleton, screenshots are capped at 1024×768, and only the last two pages stay in the thread
  • Model evals are graded by code against fixture pages
Personal · Multi-Agent Systems

Agent Harness

Model-agnostic harness for building multi-agent systems and workflows

A harness I built for myself to create and run multi-agent systems and workflows for my own use cases, on any model. Agents are defined in files and run as subagents, in the background or in their own git worktrees, each on the model that suits it. Workflows are short JavaScript scripts that fan work out to agents in parallel or in pipelines. One headless engine runs everything, with a VS Code extension, a terminal CLI and an Electron app as front ends.

TypeScriptVercel AI SDKVS Code APIElectronReactSQLitenode-pty
Why I built it →

Challenge

I wanted to build multi-agent systems for my own tasks and mix models inside one system. The agent tools I used each handled part of this well, and each was tied to its vendor's models.

Solution

Each agent has its own prompt, tools and model, and the harness also reads agent files from existing Claude Code, Cursor and Codex projects. A parent agent starts subagents up to three levels deep and ten at a time, in the background or in an isolated git worktree, and can resume them by ID. Workflows are JavaScript scripts built from agent(), parallel(), pipeline() and phase() calls. They run in a sandboxed worker that can't read the clock or random numbers, so a re-run replays every step that already finished. Underneath, each turn streams from the model through the Vercel AI SDK, starts tool calls as they arrive, snapshots files with shadow git around every edit, and runs shell commands in a macOS Seatbelt sandbox.

Impact

A new multi-agent system for one of my tasks is a few agent files and a workflow script, with each agent on whichever model fits. In the first end-to-end test, GPT-5.5 and Claude Sonnet 5.5 each completed the same task in a real repo, for $0.61 and $0.12.

Core features

  • Agents defined in files, each with its own prompt, tools and model
  • Subagents up to three levels deep and ten at a time, in the background or in their own git worktrees
  • JavaScript workflows that fan work out to agents in parallel steps and pipelines
  • Workflow re-runs replay finished steps, so a failed run picks up where it stopped
  • 13 model providers, from OpenAI, Anthropic and Google to local models through Ollama and LM Studio
  • Skills, slash commands and agent files read from existing Claude Code and Cursor projects
  • VS Code extension with inline Keep and Undo for each change, and a CLI with review, undo and rewind

Engineering highlights

  • The engine has no Electron or VS Code imports and talks to every front end over typed JSON-RPC
  • Tool calls start mid-stream under an ordered read/write lock, with reads in parallel and writes one at a time
  • Switching models mid-session rewrites tool calls the new model can't use into plain text
  • Cost is tracked per step, cached tokens included, and stored in SQLite
  • Project settings and rules files are untrusted, so a cloned repo can't redirect API keys or loosen the sandbox
  • Over 1,100 unit tests, plus Electron end-to-end and VS Code extension suites
  • In progress on a branch: agent teams that build in parallel waves, and best-of-N runs across models with a judge
Flagship · Product Engineering

AI Builder

No-code website builder for the restaurant industry

A publishing platform where restaurant teams design, collaborate on, and ship their own websites. Staging workflows, analytics, and automated AWS deployment are part of the platform.

Next.jsReactTypeScriptNode.jsAWSGA4 APISearch Console API

Challenge

Restaurant businesses needed fast, well-built websites without hiring engineers, and the platform behind those sites had to handle publishing, collaboration, SEO, accessibility, and hosting across many clients at once.

Solution

A no-code builder with a drafting and templating engine, Live and Staging publishing workflows, real-time collaborative editing, and a publishing pipeline that provisions domains and SSL on AWS automatically. I led the migration from Gatsby to Next.js for a rendering architecture that scales better.

Impact

Website delivery became self-serve. A restaurant site goes from draft to a live, accessible, SEO-ready deployment without an engineer in the loop.

Core features

  • Live / staging publishing workflows with safe promotion
  • Collaborative multi-user editing environment
  • Drafting & templating engine for rapid site creation
  • Analytics dashboard on GA4 + Google Search Console APIs
  • Media library with editing and an optimization pipeline
  • Independent mobile-specific CSS override system
  • Domain & SSL configuration automation on AWS

Engineering highlights

  • Gatsby → Next.js migration for scalable architecture
  • ADA-compliant rendering across generated sites
  • Strong Core Web Vitals / Lighthouse focus on published output
  • Publishing workflow designed to scale across many client sites
Flagship · AI Agent Engineering

AI Trading Assistant

LLM-powered financial copilot with tool orchestration

An AI assistant that puts LLM reasoning on top of real portfolio data, with streaming chat, RAG over financial context, market and news lookup, and multi-step tool orchestration.

FastAPINext.jsLangChainOllamaChromaDBPythonTypeScript

Challenge

A general chatbot can discuss markets but cannot touch a user's actual portfolio. I wanted an assistant that reasons over live holdings, retrieves the context that matters, and runs multi-step workflows through real tools.

Solution

A LangChain-based agent with ReAct-style tool orchestration behind a FastAPI backend and a Next.js streaming chat frontend. ChromaDB powers RAG retrieval, persistent memory keeps conversations context-aware, and the agent plans multi-step reasoning chains across portfolio, pricing, and news tools.

Impact

An agent that observes, reasons, retrieves, and acts on real user data, on the architecture I would use in production.

Core features

  • Streaming chat UI built with Next.js
  • Ollama LLM integration behind FastAPI
  • Portfolio analysis & market insights
  • Portfolio CRUD tools the agent invokes directly
  • Coin price lookup & financial news retrieval tools
  • Persistent memory with context-aware multi-step reasoning

Engineering highlights

  • LangChain agent framework with ReAct-style tool orchestration
  • ChromaDB vector store powering the RAG pipeline
  • Reasoning, retrieval, and tool execution kept in separate layers
  • The agent plans and executes across several tools per request
Enterprise Platform

Business Operations Management System

Modular platform for core business operations

An operations platform covering purchasing, shipping, invoicing, and finance, built as a modular monorepo with separate business domains.

TypeScriptReactNode.jsNestJSPostgreSQLMonorepo

Challenge

Growing businesses juggle purchase orders, shipments, invoices, and financial records across disconnected tools, losing visibility and duplicating work.

Solution

One platform for those workflows. Domains like Inventory, Finance, and CRM live as separate modules inside a monorepo, so the system stays maintainable while the workflows themselves stay connected.

Impact

One system of record for operations, from purchase through payment, in place of scattered spreadsheets and manual handoffs.

Core features

  • Purchase orders, shipping, and invoicing workflows
  • Financial workflows & reporting
  • Vendor & customer management
  • Activity tracking & operational automation

Engineering highlights

  • Modular monorepo architecture
  • Separated domains: Inventory, Finance, CRM
  • Structured to stay maintainable as operations grow
Real-Time Systems

Virtual Classroom & LMS Platform

Live teaching platform with real-time collaboration

A learning management system with live virtual classrooms: scheduling, video, whiteboarding, and multi-role portals for teachers, sales, and admins.

JavaScriptReactNode.jsWebRTCWebSockets

Challenge

Video calls on their own left remote classes without scheduling, interactive teaching tools, or workflows for the different roles in a school.

Solution

An LMS with real-time classroom infrastructure: class scheduling, video and screen sharing, collaborative whiteboarding with annotations, and live chat, plus a dedicated portal for each role in the organization.

Impact

Teachers ran structured remote lessons using tools a plain video call does not provide.

Core features

  • Class scheduling & management
  • Video conferencing & screen sharing
  • Whiteboarding with live annotations
  • Real-time chat
  • Teacher, sales, and admin portals

Engineering highlights

  • Real-time multi-user infrastructure
  • Role-based product surfaces on a shared platform

Apps

Apps I build for myself

Phone and Mac apps I wrote for my own devices. They share one monorepo of TypeScript packages and native Kotlin and Swift modules, and my phone installs them from a private store I also built.

Android

Deputy

Phone agent that operates other apps

Takes a task in plain words and carries it out by reading the screen and tapping, typing and scrolling through other apps with an accessibility service. The agent loop runs in Kotlin, and it stops to ask before any step it can't undo. It can also turn photos on the phone into a video by itself, without driving an editing app.

React NativeKotlinAccessibility APILLM tool calling
Android · Chrome

Strongroom

Password manager in my own code

Keeps logins, cards and notes in a vault encrypted with Argon2id and AES-256-GCM, and fills them into other apps through Android's autofill service. A Chrome extension fills websites, and sync runs through my own Cloudflare Worker, which only ever holds ciphertext.

KotlinReact NativeAndroid AutofillChrome extensionCloudflare Workers
Android · iOS

HomeNet

Home network scanner and diagnostics

Scans the home Wi-Fi network, names each device from reverse DNS, mDNS, SSDP and NetBIOS replies, and runs connectivity checks. It finds hosts with bounded TCP probes because Android and iOS block the ARP table. There is no telemetry, and every dependency is open source.

React NativeExpoTypeScriptKotlinSwift
Android

TunnelWall

VPN client and per-app firewall

Connects to free VPN Gate relays or to your own WireGuard servers, with no account or sign-up. A built-in firewall shows data use per app, can block an app on mobile data or everywhere, and keeps a local activity log.

React NativeTypeScriptKotlinOpenVPNWireGuard
Mac · Android

Design Editor

Offline Canva-style editor with media tools

A design canvas for the Mac built on Electron and Fabric.js, with the same canvas on Android in a WebView. Its media tools compress video to a size limit, clip, convert and make GIFs, using FFmpeg on the Mac and a background Kotlin job queue on the phone.

ElectronFabric.jsFFmpegReact NativeKotlin
Android

Store

Private app store for my own apps

Installs and updates the Android apps on this page, itself included. Before every install it checks the file's SHA-256 hash, the package name and the signing certificate. Builds are published from the command line to a Cloudflare Worker that hands out signed download links.

React NativeKotlinWorkManagerCloudflare Workers

Experience

Five years of shipping production software

From sole frontend developer to senior engineer owning platform architecture, publishing infrastructure, and AI features.

Outsentia · Senior Software Engineer

June 2026 — Present

Building AI agents for a financial research firm, along with the internal platform they run on: earnings and transcript agents, a browser automation app, and the sign-in service in front of their internal apps.

  • Built a multi-agent financial research platform (TypeScript/Mastra) automating earnings monitoring, analyst report drafting, and research chat
  • Designed a self-healing daily monitor that ingests earnings/event data, drafts digest emails, and updates calendars unattended via MCP integrations (Aiera, Gmail, Drive, Calendar)
  • Rebuilt a 5-pass pipeline that turns Zoom expert-call transcripts into analyst anecdotes, with a review queue and an editor agent that learns house rules
  • Built a research chat agent with semantic memory recall over shared and private knowledge bases
  • Built and deployed a central sign-in and access-policy service on Cloudflare Workers and AWS, now in front of four internal apps
  • Built an Electron agent that drives Chrome with Claude and saves runs as routines that replay without the model
  • Kept dedup, state, and templating in code, with LLM calls scoped to bounded judgment tasks (structured in, structured out)
  • Developed a custom React front end for research operations and streaming agent interaction

AIO · Senior Full Stack Engineer

April 2024 — June 2026

Led full stack development on a no-code website publishing platform for the restaurant industry, from rendering architecture through deployment automation.

  • Built a dual-environment publishing system (Live / Staging) with safe promotion workflows
  • Led the Gatsby to Next.js migration for a rendering architecture that scales better
  • Designed protected public APIs and a full website management suite
  • Shipped a GA4 / Google Search Console analytics dashboard
  • Built the templating and drafting system powering rapid site creation
  • Created an image library with editing and an optimization pipeline
  • Engineered an independent responsive styling engine with mobile-specific overrides
  • Built ADA-compliant architecture and held a high Lighthouse and Core Web Vitals bar
  • Built collaborative tools with real-time multi-user synchronization
  • Developed dynamic form builders and AWS-driven deployment automation
  • Automated domain and SSL provisioning; led product-driven UX improvements

99 Technologies · Frontend Engineer

Jan 2022 — March 2024

Joined as the sole frontend developer and helped grow the team's engineering capability while leading key product frontends.

  • Led frontend development of an inventory management system
  • Built the SJ Computers e-commerce frontend with Next.js and Material UI
  • Implemented checkout flows and guest user management
  • Maintained backend APIs supporting frontend integration
  • Mentored engineers as the frontend practice grew

2nd Mouse Venture · Web Developer

Dec 2020 — Dec 2021

Built real-time education technology: an LMS and virtual classroom platform used for live remote teaching.

  • Developed class scheduling and management workflows
  • Built video conferencing and screen-sharing features
  • Implemented collaborative whiteboarding with annotations
  • Added real-time chat across the classroom experience
  • Delivered dedicated portals for teachers, sales, and admin roles

AI Engineering

AI systems I build

Agents that plan and execute, retrieval pipelines grounded in real data, and assistants that hold memory, call tools, and run behind guardrails in production.

Capabilities

AI agentsAutonomous agent workflowsRAG pipelinesTool-using LLM systemsContext-aware assistantsStreaming AI chat interfacesPrompt orchestrationMemory-enabled assistantsVector databasesFinancial & business AI copilotsAI automation pipelinesModel Context Protocol (MCP)Multi-agent orchestrationBrowser automation agentsAgent evals & monitoring

I build the agent and the product around it. The same system that runs the agent also handles auth, streaming, persistence, deployment, and the interface users touch.

How my AI systems are shaped

01
Triggerscheduled run / user query
02
RetrieveRAG · vector search · APIs
03
ReasonLLM planning · ReAct loops
04
Acttool calls · CRUD · services
05
Deliverstreams · digests · drafts

Orchestration stays deterministic and the LLM handles the reasoning steps. Retrieval, memory, and tool execution are designed in from the start.

Autonomous Agent · In Production

Autonomous financial-events agent

An autonomous LLM agent (Mastra, TypeScript, Claude) monitors financial events daily and generates analyst-grade earnings digests and email drafts. It pulls from several external data and productivity services through a pipeline orchestrated in code.

MastraTypeScriptClaudeAgent OrchestrationExternal API Integration
Currently exploringAgentic workflows, multi-agent systems, and how applied-AI products should be structured as they grow.

Skills

The stack I work in

What I use day to day: the TypeScript ecosystem, cloud infrastructure, and current AI tooling.

Full Stack

TypeScriptReactJSNextJSNestJSNode.jsGatsbyTailwind CSSReduxZustandElectronReact NativeKotlin

AI & Data Engineering

Generative AIRAG PipelinesAgentic WorkflowsLangChainLlamaIndexModel Context Protocol (MCP)MastraVercel AI SDKClaude API

Databases & Infrastructure

PostgreSQLMySQLSQLiteAWSCloudflare WorkersDockerLinuxCI/CD

Developer Productivity & Tools

GitClaude CodeCursorPlaywrightv0.devPostman

Background

Education and certifications

Education

Bachelor of Science in Computer Science

COMSATS University Islamabad

2017 — 2021

Certifications

  • Architecting Solutions on AWS

    Coursera · AWS

  • Application Development using Microservices and Serverless

    Coursera · IBM

  • AWS Generative AI for Developers

    FutureLearn

Contact

Let's talk

I'm open to senior full stack roles, AI engineering work, applied AI and agentic workflow projects, and consulting or freelance product development. If that sounds like what you're building, send me a note.