pmdnawaz1

By the Numbers

Eighteen months, measured. Every system below was designed, built, and deployed solo.

Systems

Ordered by the layer they sit at, not by the date they shipped. The infrastructure comes first because that is where the work is now.

The systems that make AI development possible: agent runtimes, provider gateways, MCP servers, and a compiler for code knowledge.

Stack

Not a list of everything I have touched. These are the tools I reach for when a system has to survive contact with production.

• AI & Agent Infrastructure

  LangChain, LangGraph
  MCP protocol & servers
  OpenAI, Anthropic, Gemini
  Groq, Mistral, Ollama
  pgvector, Qdrant, Neo4j
  Embeddings & hybrid search
  Multi-provider fallback
  Circuit breaking, token rotation
  

• Backend & Systems

  Go: Gin, Fiber, GORM
  Python: FastAPI, Celery, ARQ
  Node.js: Express, tRPC
  PostgreSQL, MongoDB, Redis
  WebSockets, WebRTC
  Clean architecture
  Multi-tenant schema design
  RBAC & OAuth 2.1
  

• Program Analysis

  Tree-sitter parsing
  Intermediate representations
  Composable compiler passes
  Ontology-driven modelling
  LSP integration
  Multi-language analysis
  ADR-driven architecture
  Vitest, property testing
  

• Frontend & Product

  Next.js 16, React 19
  Vite 8, TypeScript 6
  tRPC end-to-end types
  Zustand, TanStack Query
  Tailwind, Styled Components
  Radix UI, Shadcn
  Flutter & Dart
  VS Code extensions
  

• Infrastructure & Delivery

  Docker multi-stage builds
  docker-compose, PM2
  nginx reverse proxy
  Auto-rollback deploys
  Vercel, VPS, AWS S3
  Stripe billing & metering
  GitHub App integrations
  Poetry, uv, pnpm, Turborepo
  

The Arc

I did not start as an AI engineer. I started as a builder who shipped fast. Every three to six months since, I have moved up a layer of abstraction.

1. 2024

   The JavaScript Proliferation

   WhatsApp tools, finance apps, an Instagram downloader, a pharma e-commerce site. These were not deep projects, they were reps. Each one taught me something about React, Express, or MongoDB. Quantity over quality; learning by shipping.

2. Late 2024

   TypeScript & First Clients

   I got tired of runtime errors that a compiler could have caught, and started reaching for TypeScript on everything. Then Leeuwenhoek Technologies became my first real client: a microscopy firm, a real business, a real deadline.

3. Mid 2025

   The AI Inflection Point

   Two AI projects launched in the same week. A FastAPI presentation generator calling Ollama on my own machine, and a Next.js resume builder on Google Gemini. I learned the AI stack from both sides at once: local and cloud.

4. Aug 2025

   Serious Go

   A delivery route optimization engine: an allocation algorithm, tiered payments, a 100km daily driver limit, a background scheduler. Not AI, but algorithmic logistics. It proved I could write systems code, not just wire up frameworks.

5. Early 2026

   MCP Discovery

   My first Model Context Protocol server: tools, vector memory, and decision tracking exposed to AI agents. In parallel, a genuinely multi-tenant SaaS on Next.js 16 and tRPC with separated global and tenant schemas. The identity started to crystallize: build the infrastructure first, then build on it.

6. Spring 2026

   Production Platforms

   Three client platforms in three months. The Induckt VC platform: four repositories, 52 commits, four weeks, from Go/Gin backend to investor portal. A Go/Fiber social backend with WebSocket presence for Renyra. Delivery at scale, for real businesses.

7. Now

   Agent-Native Architecture

   Four major systems in six weeks: CodeOrch, Maintainer OS, Sync-Key, IRI. All of them beneath the application layer. Every MCP experiment, every AI integration, every architecture pattern, consolidated. I build the infrastructure that AI-native development runs on.

The strongest signal is not any single project, it is the trajectory. In eighteen months I went from building React apps to designing a multi-language knowledge compiler. Each phase was built out of the one before it: the MCP experiments became CodeOrch, the Go experiments became production platforms, a single OpenAI integration became a fourteen-provider gateway. I am not an engineer who learns technologies. I learn patterns, then build the infrastructure that makes them reusable.

How I Build

Four patterns show up in every repository, whether the output is a compiler or a landing page.

• 01

  Build abstractions before applications

  An MCP server became CodeOrch. A single provider integration became Sync-Key. Direct LLM calls became LangGraph orchestration. The application is always the second thing I build.

• 02

  Ship platform-grade, solo

  CodeOrch spans four sub-applications, three languages, and a production PM2 deployment with auto-rollback. Induckt was four repositories in four weeks. Designed, built, and deployed alone.

• 03

  Learn by building infrastructure

  I do not do tutorials. I learn a technology by building production infrastructure with it, which is why the first Go project was a route optimizer and the first Tree-sitter project was a compiler.

• 04

  Iterate up the stack

  Every three to six months I operate one layer higher. Web apps, then AI integration, then agent infrastructure, then knowledge compilation. Each phase is built out of the one before it.