Skip to content
abdul mannanGet in touch

I build backend systems — and the AI agents that run on them.

Solo, end-to-end, accountable for the whole thing. 3+ years in production, 25+ systems owned, 10+ third-party integrations shipped.

Hire me for a projectSee what I fix
abdul@abxcodes.xyz
What I can build for you
  • Complete backend developmentAPIs, services, data layers
  • AutomationsCode and no-code, wired together
  • Web scrapingAt scale, past rate limits
  • AI agentsTool calling, self-repair
  • API integrationsCRMs, ad networks, payments
Platforms I build on
  • Node.js
  • TypeScript
  • Python
  • Express
  • PostgreSQL
  • MongoDB
  • MySQL
  • Redis
  • ClickHouse
  • Puppeteer
  • Selenium
  • Proxy networks
  • Email validation
  • Database design
  • OpenAI
  • Google Gemini
  • LangChain
  • AI agents
  • Pandas & NumPy
  • n8n
  • Zapier
  • HubSpot
  • Meta
  • Google Ads
  • Workflow engines
  • Sync & migration
  • Attribution
  • AWS
  • OpenSearch
  • Docker
  • Vercel
  • Cloudflare
  • Stripe
  • Razorpay
  • DNS & TLS
Problems I solve

The work I get hired for

Backend services that hold the data, integrations that move it between platforms, scrapers that collect it, and agents that act on it. Most of it sits in the unglamorous middle — and all of it has to keep running when nobody is watching.

AI agents & LLM pipelines

You want AI doing real work, not a chatbot bolted onto the side.

  • Built production agents, not prototypes — shipped into live workflows and left to run unattended, with other teams depending on the output
  • Built small task-specific agents for internal jobs, each one taking a repetitive manual process and carrying it end to end without supervision
  • Designed with real failure handling — tools, retries and bounded recovery — because an agent that only works when nothing goes wrong is not one you can walk away from
See the agent case study
  • OpenAI
  • Gemini
  • LangChain
  • ClickHouse

Lead ingestion & attribution pipelines

Leads arrive from six places and nobody can say which ad produced them.

  • Architected end-to-end flows covering ad parameters, lead ingestion, attribution, CRM sync and downstream tasks
  • Traced attribution back to the originating ad so spend could be judged on outcomes rather than impressions
  • Kept the whole chain running unattended, with the failure points removed rather than worked around
  • Node.js
  • TypeScript
  • Webhooks
  • REST

Large-scale scraping & data extraction

You need data that lives behind rate limits, IP blocks and pagination.

  • Built and operated scraping fleets using rotating proxy services and anti-blocking techniques
  • Designed email extraction and validation covering 83,000+ mail providers worldwide
  • Owned the supporting databases, monitoring and long-term maintenance, not just the first successful run
  • Node.js
  • Python
  • Puppeteer
  • Proxies
  • PostgreSQL

Payment webhooks & transaction reliability

Payments silently fail and you find out from an angry customer.

  • Cleared blocking gateway failures on live transaction flows, restoring checkout rather than scheduling a fix
  • Traced each failure through provider dashboards, application logs and database state instead of guessing at the cause
  • Worked the incidents alongside the teams who reported them, which is how the real cause surfaced
  • Stripe
  • Razorpay
  • Node.js
  • Webhooks

Cost reduction & vendor consolidation

Recurring bills crept up and nobody owns the line items.

  • Engineered recurring monthly savings across three separate production systems
  • Audited overlapping tooling and replaced paid connectors with integrations we owned outright
  • Rearranged storage and send flows to stop cost creeping back, rather than trimming it once and moving on
  • AWS
  • Warehousing
  • Vendor audit
  • Usage analysis

Email deliverability & marketing flows

Campaigns land in spam, or the automation quietly stops firing.

  • Reworked core marketing automation flows to remove failure points, choosing long-term stability over quick fixes
  • Handled mail configuration and sending infrastructure end to end, including the DNS records deliverability depends on
  • Protected the lead funnel through the changes, with no downtime across the period
  • SendGrid
  • SMTP
  • DNS
  • SPF/DKIM
  • Node.js
Core backend

How the backend work is actually done

The layer everything else sits on — where the data lives, how requests are validated and authorised, what happens when a third party fails halfway through, and how a bad run gets unwound.

APIs and service design

Services where the schema is designed alongside the endpoints rather than bolted on after. Validation at the boundary so malformed input never reaches business logic, and authorisation decided per route instead of checked wherever someone remembered to.

Evidence

Node.js, Express and TypeScript services with Zod validation at the edge, JWT authentication and role-based access control. Database design reviewed and agreed before implementation, not discovered during it.

  • Node.js
  • Express
  • TypeScript
  • Zod
  • JWT
  • RBAC

Data modelling and storage

Picking the store that fits the shape of the data, then making it hold up under volume. Relational schemas with real constraints where the relationships matter, document models where they do not, and a separate analytical store so reporting queries never touch the transactional one.

Evidence

Backend services running against a MongoDB database holding millions of documents. PostgreSQL and MySQL schemas through Prisma and Mongoose. A ClickHouse star schema with separate fact and dimension tables behind the analytics agent.

  • PostgreSQL
  • MongoDB
  • MySQL
  • ClickHouse
  • Prisma
  • Mongoose

Caching and query performance

Finding the bottleneck before changing anything, because the obvious suspect is usually not the guilty one. More often than not it is a missing index, a cache layer nobody added, or work happening in application code that the database was built to do.

Evidence

Introduced Redis caching across backend services, improving API call efficiency by roughly 30%. Query and index tuning on high-volume collections, with pm2 logs used to find where the time actually went.

  • Redis
  • Indexing
  • Query plans
  • pm2

Integrations and webhooks

Tokens that expire, calls that fail halfway through, providers that disagree about the state of the world. Written so a failed run can be repeated safely instead of leaving a record in two places at once.

Evidence

10+ third-party APIs across ad networks, CRMs, feedback forms and payment providers. Diagnosed and cleared blocking payment webhook failures on live Stripe and Razorpay transaction flows. Replaced a paid connector with a direct integration, removing both the cost and a failure point.

  • REST
  • OAuth
  • Webhooks
  • Stripe
  • Razorpay
  • Meta

Migrations and batch processing

Moving data between systems without losing it, duplicating it, or discovering a month later that half of it was malformed. Validation before the write, deduplication at the destination, and scripts built so an interrupted run can be started again from where it stopped.

Evidence

Moved 15,000+ lead records between CRMs at roughly half the previous processing cost. Every migration was built to be re-run rather than hand-repaired when it failed partway.

  • Node.js
  • Batch scripts
  • Validation
  • Deduplication
  • REST

Running it in production

Everything after the deploy: process management, debug logs that are actually readable at 2am, alerting tuned to fire on the things that matter, and infrastructure hardened against the failure that has not happened yet.

Evidence

pm2 process management and log-driven debugging of live incidents. Configured infrastructure across OpenSearch, AWS services, DNS and database security. Zero major production incidents on the systems I owned end to end.

  • pm2
  • OpenSearch
  • AWS
  • DNS
  • Logging
Agentic work

AI that does the job, not a chatbot bolted on the side

An agent that plans, queries, executes code, checks its own work and repairs its own failures — with the cost of every step decided deliberately.

Flagship2025 — ongoingSolo — design, build, operate

EcomAnalysisAgent

Ask a business question in English. Get a validated answer from the warehouse.

An agent that turns plain-English business questions into validated SQL against a ClickHouse star schema, executes sandboxed Python for the analysis, returns charts — and repairs its own failures along the way.

  • Next.js
  • TypeScript
  • ClickHouse
  • OpenAI
  • Vercel AI SDK
  • Zod
  • Python
Pipeline stages

4

validate · plan · generate · execute

Bounded self-repair

3

retries before it gives up cleanly

Query timeout

30s

hard cap per execution

Context ceiling

10k

rows sampled before truncation

How a question becomes an answer

  1. 01gpt-4o-mini

    Validate the question

    Decides whether the request is answerable from the available schema before spending anything on it.

    lib/prompts/query-validation.tsbudget 800 tokens
  2. 02gpt-4o

    Plan the analysis

    Chooses what to compute and how, given the question and the table shapes.

    lib/prompts/analysis-strategy.tsbudget 2000 tokens
  3. 03gpt-4o-mini

    Write the SQL

    Generates a ClickHouse query against the injected schema and checks it before execution.

    lib/prompts/query-generation.tsbudget 800 tokens
  4. 04gpt-4o-mini

    Run, then repair

    Executes the query, writes a Python script for the analysis, runs it in a sandboxed subprocess, and returns the charts.

    lib/prompts/error-fixing.tsbudget 1000 tokens

Cost is an engineering decision

The expensive model is reserved for the one stage that actually needs reasoning. Everything else runs on a cheaper model with a hard token budget, because at volume the difference between “works” and “works affordably” is the whole project.

Per-stage routing, from lib/config/constants.ts
StageModelToken budgetWhy this model
VALIDATIONgpt-4o-mini800Cheap model, narrow task — classification only.
QUERY_GENERATIONgpt-4o-mini800The schema is injected, so the model is transcribing rather than reasoning.
ANALYSIS_STRATEGYgpt-4o2000The one stage that needs real reasoning — the only place the expensive model pays for itself.
ERROR_FIXINGgpt-4o-mini1000Fixes are local and mechanical; the error text carries most of the signal.

Self-healing execution

Query errors, invalid scripts and schema mismatches are caught and fed back for repair, bounded to three attempts so a broken run fails cleanly rather than looping.

Sandboxed code execution

The agent's generated Python runs as an isolated subprocess — pandas, matplotlib, seaborn — with a validator between generation and execution.

Context discipline

Large result sets are sampled rather than pasted into the prompt, with explicit caps on rows, sample size and characters per sample.

Resilient parsing

Malformed model output is recovered through a five-strategy parse before it is ever treated as a failure.

Two front ends

A streaming chat interface and a CLI over the same agent core, with every session logged to disk — generated SQL, scripts, charts and token usage.

Experience · 2023 — 2026

Three years of owning systems end to end

Roles described by what they involved rather than where they were. Full detail available on request.

2025 — 2026Hyderabad · onsite

Full Stack Developer — Backend Focus

Sole owner of the backend behind a marketing-automation platform, running 25+ production systems end to end.

  • Held full lifecycle ownership of the whole system — design, deployment, monitoring and ongoing maintenance — with zero major incidents on anything I was responsible for
  • Worked directly with the sales, marketing and product teams who depended on those systems, and cleared the failures they raised
  • Cleared a backlog of technical debt: refactored legacy paths and hardened DNS, cloud services, database security and search
  • Cut spend across three systems — a warehouse migration, a paid connector replaced with our own integration, and redesigned storage flows
  • Researched and pitched a Deep Research initiative aimed at improving sales outcomes and ad effectiveness
  • Node.js
  • TypeScript
  • PostgreSQL
  • MongoDB
  • AWS
  • OpenSearch
  • Stripe
  • Razorpay
  • SendGrid
  • OpenAI
2024 — 2025Hyderabad · onsite

Full Stack Developer — Backend Focus

Built secure, scalable APIs for a microservices backend holding millions of documents.

  • Designed, built and debugged APIs for a microservices architecture backed by a database with millions of documents
  • Implemented Redis caching across backend services, improving API efficiency by roughly 30%
  • Delivered payment gateway and third-party API integrations, including the reconciliation logic that keeps them correct
  • Worked directly with the CTO, tech lead and international clients to resolve live production bugs
  • Shipped a client project inside three months and mentored incoming interns
  • Node.js
  • Express
  • TypeScript
  • MongoDB
  • Redis
  • React
  • pm2
2023 — 2024Remote · remote

Backend Developer

First production backend role: REST APIs and CRUD automation for a learning management system.

  • Designed, wrote and tested REST APIs for a learning management system and SQL CRUD automation projects
  • Worked within a team of eight, mentored by senior developers, and received a letter of appreciation on completion
  • Built and shipped a full-stack banking application as part of an earlier internship
  • Node.js
  • Express
  • MySQL
  • EJS
  • HTML/CSS
Education

B.E. Computer Science & Engineering · Osmania University · 2019 — 2023 · 7.77 / 10

Available now

Tell me what’s broken, or what you want built.

Available for freelance and contract work — backend builds, integrations, pipelines, and the agents that run on top of them.

Prefer email?
Or send a brief