Solo, end-to-end, accountable for the whole thing. 3+ years in production, 25+ systems owned, 10+ third-party integrations shipped.
abdul@abxcodes.xyzBackend 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.
You have a spec, and no one to take it from document to production.
You want AI doing real work, not a chatbot bolted onto the side.
Leads arrive from six places and nobody can say which ad produced them.
You need data that lives behind rate limits, IP blocks and pagination.
Payments silently fail and you find out from an angry customer.
Recurring bills crept up and nobody owns the line items.
Campaigns land in spam, or the automation quietly stops firing.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
An agent that plans, queries, executes code, checks its own work and repairs its own failures — with the cost of every step decided deliberately.
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.
4
validate · plan · generate · execute
3
retries before it gives up cleanly
30s
hard cap per execution
10k
rows sampled before truncation
Decides whether the request is answerable from the available schema before spending anything on it.
Chooses what to compute and how, given the question and the table shapes.
Generates a ClickHouse query against the injected schema and checks it before execution.
Executes the query, writes a Python script for the analysis, runs it in a sandboxed subprocess, and returns the charts.
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.
| Stage | Model | Token budget | Why this model |
|---|---|---|---|
| VALIDATION | gpt-4o-mini | 800 | Cheap model, narrow task — classification only. |
| QUERY_GENERATION | gpt-4o-mini | 800 | The schema is injected, so the model is transcribing rather than reasoning. |
| ANALYSIS_STRATEGY | gpt-4o | 2000 | The one stage that needs real reasoning — the only place the expensive model pays for itself. |
| ERROR_FIXING | gpt-4o-mini | 1000 | Fixes are local and mechanical; the error text carries most of the signal. |
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.
The agent's generated Python runs as an isolated subprocess — pandas, matplotlib, seaborn — with a validator between generation and execution.
Large result sets are sampled rather than pasted into the prompt, with explicit caps on rows, sample size and characters per sample.
Malformed model output is recovered through a five-strategy parse before it is ever treated as a failure.
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.
Roles described by what they involved rather than where they were. Full detail available on request.
Sole owner of the backend behind a marketing-automation platform, running 25+ production systems end to end.
Built secure, scalable APIs for a microservices backend holding millions of documents.
First production backend role: REST APIs and CRUD automation for a learning management system.
B.E. Computer Science & Engineering · Osmania University · 2019 — 2023 · 7.77 / 10
Available for freelance and contract work — backend builds, integrations, pipelines, and the agents that run on top of them.