Kartik Parmar / Forward Deployed Engineer I build AI products and backend systems that make it past the demo.
Forward deployed engineer with 5+ years in backend systems and DevOps, now building AI products end to end: RAG pipelines, agentic workflows, Python backends and the web apps people actually use. I work close to the problem, design the system and ship it to production on AWS, GCP, Azure or wherever it needs to run.
- focus
- AI products · Backend systems · DevOps
- core
- python / fastapi / postgresql / langchain / aws / gcp / azure
01Selected work
Systems designed, built and kept running.
Case studies from real projects. Each one covers the problem, what I owned and the engineering decisions that mattered. Company and client names are left out on purpose.
- Role
- Senior Software Engineer
fig. 01 · request trace. Flow: Patient data (trial records), then API (FastAPI), then Task queue (Celery), then Narrative (LLM generation), then Database (PostgreSQL). The problem
Clinical trial teams need patient and case narratives: consistent, submission-ready write-ups built from details in patient records. Producing them by hand is slow, repetitive work.
What I did
- Designed and owned the Python microservices backend
- Built the services on FastAPI and PostgreSQL, using Celery workers for background jobs
- Deployed the backend as a distributed system across AWS, GCP and Azure
- Cut narration time from 3 hours to 5 minutes
Decisions that mattered
Microservices with background workers
Generating a narrative takes far longer than a web request. Running that work on Celery workers keeps the APIs responsive and lets each service scale on its own.
Stack
- Python
- FastAPI
- PostgreSQL
- Celery
- LLMs
- AWS
- GCP
- Azure
fig. 02 · request trace. Flow: Literature (journals), then Triage (case reports), then Extract (key details), then Report (E2B(R3)), then QC review (audit trail). The problem
Drug safety teams must regularly screen published medical literature for reports of side effects involving their medicines, then turn each valid case into a structured report for regulators. Doing that by hand across large volumes of articles is slow, repetitive work.
What I did
- Picked up the project mid-development and started shipping changes quickly
- Optimised the platform's existing AI agents
- Implemented a new AI orchestration layer for better generation and job queuing
- Fixed authentication issues and strengthened the platform's security
- Implemented a freemium model so new users can try the product through a demo
Decisions that mattered
Improve the agents and their orchestration instead of starting over
The AI agents already existed, so the biggest gains came from optimising them and coordinating generation and queuing better, without the risk of a rewrite.
A freemium tier for trying the product
New users can try the platform for themselves in a demo before committing to it.
fig. 03 · request trace. Flow: Brand data (products · docs), then Ingestion (pipeline), then Trends (research), then Audience (taste analysis), then Ideas (new products). The problem
Brands sit on years of product data and documentation, but turning it into a clear view of what their audience wants next means slow, manual research across that data and fast-moving market trends.
What I did
- Built the data ingestion pipeline that turns a brand's product data and documentation into content the AI can analyse
- Worked on the research flow that analyses a brand's audience and their tastes alongside the latest trends
- Helped turn that analysis into concrete suggestions for new products
Decisions that mattered
Ground ideas in the brand's own data
Suggestions start from the brand's actual products and documentation rather than generic trends, so they fit what its audience already likes.
fig. 04 · request trace. Flow: Documents (PDF · scans), then Ingest API (FastAPI), then Job queue (idempotent), then Parse (LlamaParse), then Records (PostgreSQL). The problem
Amplify AI's product ideas are only as good as its reading of a brand's documents, so source files had to be extracted accurately before anything reached the analysis. Fully automating extraction wasn't safe either: a wrongly extracted field is worse than one that waits for human review.
What I did
- Designed and built the ingestion, extraction and validation pipeline that feeds Amplify AI
- Wrote the first extractor on PyMuPDF, then switched extraction to LlamaParse for more accurate results
- Built the FastAPI service and async workers that process documents in the background
- Validated extracted data against Pydantic schemas and sent low-confidence results to a review queue
Decisions that mattered
Move from a custom PyMuPDF extractor to LlamaParse
PyMuPDF extracts text and layout quickly, but tables and scanned pages need custom logic or OCR on top of it. LlamaParse's model-based parsing keeps table structure and handles scans, so switching to it made extraction more accurate.
Treat extracted output as untrusted input
Every result is validated against a strict schema and retried or escalated when it fails. Bad data never reaches the analysis silently.
Idempotent jobs keyed by document hash
Each document's hash maps to exactly one job, so repeat uploads and worker restarts can't create duplicate records, and failed jobs can be retried aggressively.
Stack
- Python
- FastAPI
- Pydantic
- LlamaParse
- PyMuPDF
- Azure OpenAI
- PostgreSQL
- Azure Blob Storage
- Docker
- Period
- 2024 to now
- Role
- Backend engineer
fig. 05 · request trace. Flow: Website URL (input), then API (FastAPI), then Workers (Celery), then Articles (LLM generation), then Blog (custom domain). The problem
Businesses know regular publishing helps them get found in search, but few have time to research topics, write articles and publish them every week. The product had to start from nothing more than a website URL and handle the rest, for many customers at once.
What I did
- Developed the entire multi-tenant backend
- Built autopilot article generation from a website URL, with topic suggestions
- Added custom domain hosting and scheduled publishing
- Integrated Umami analytics for traffic insights on each domain
- Deployed on AWS ECS and Lambda, with Celery workers and PostgreSQL
Decisions that mattered
Multi-tenant backend
Every customer gets their own hosted blog, custom domain, schedule and content, all served by one shared backend. Keeping each tenant's data separated is what lets one platform serve all of them.
Background workers for generation and publishing
Researching, writing and publishing an article is slow, multi-step work that doesn't belong in a web request. Celery workers run it in the background and on a schedule.
Stack
- Python
- FastAPI
- Celery
- PostgreSQL
- AWS ECS
- AWS Lambda
- Umami
- Links
- Internal project, not publicly available.
fig. 06 · request trace. Flow: App (sign-in), then Auth module (OIDC), then Tokens (JWT validation), then Services (protected APIs). The problem
An internal project needed its own authentication module with a proper OpenID Connect setup. Internal or not, it had to be well structured, security tested and configured to production standards.
What I did
- Built the authentication module on standard OpenID Connect flows
- Kept the codebase well structured and cleanly written
- Wrote security-focused pytest suites that cover failure cases, not just successful logins
- Set it up with production-level configuration
Decisions that mattered
OpenID Connect instead of a home-grown token scheme
A widely reviewed standard is safer than custom security logic, and any OIDC-aware client or service can integrate with it.
Security tests as part of the test suite
Authentication bugs don't crash; they quietly let the wrong request through. Tests make the failure cases explicit and keep them covered as the code changes.
Production-level configuration for an internal project
Systems that never face the public still hold real credentials. Holding configuration and secrets to the same standard as a public service avoids a risky rework later.
Stack
- Python
- OpenID Connect
- OAuth 2.0
- JWT
- pytest
02Approach
Understand the problem before touching the keyboard.
Most failed projects were well built and aimed at the wrong thing. I run every engagement as a loop: get the problem right, pick the simplest architecture that survives production, ship, then let real usage decide what's next.
Stage 1 of 5
Understand
Sit with the people who have the problem. Map the workflow, the data and the constraints nobody wrote down.
What I do
- Shadow the current workflow and find where time actually goes
- Audit the data that exists, and the data that doesn't
- Agree on what success means in numbers the business already tracks
What you get
- Problem brief
- Constraints & risks
- Success criteria
The question I keep asking
“If this works perfectly, what changes for whom?”
03Toolbox
A toolbox organised like a system, not a logo wall.
Each layer is part of how a production system comes together. Pick any tool to see what I use it for and where it shows up in my work.
6 layers , 33 tools
LLMs & OpenAI: OpenAI and other LLM APIs behind typed Python services, for generation, chat and extraction.
Layer 1: AI & LLM Engineering
Turning models into features people can trust.
inspectorstack/ai/llms-openaiL1 AI & LLM Engineering
LLMs & OpenAI
OpenAI and other LLM APIs behind typed Python services, for generation, chat and extraction.
Used in
Layer 2: Frontend & Web Apps
The part people actually use.
Layer 3: Backend & APIs
The contracts everything else depends on.
Layer 4: Databases & Systems
Where correctness actually lives.
Layer 5: Cloud & Infrastructure
Running it for real, not just locally.
Layer 6: Delivery & Leadership
Shipping it, safely and quickly.
L1 AI & LLM Engineering
LLMs & OpenAI
OpenAI and other LLM APIs behind typed Python services, for generation, chat and extraction.
Used in
04About
The part after the demo is where I do my best work.
I'm Kartik, a forward deployed AI engineer based in Ahmedabad, India. For 5+ years I've built backend systems and the infrastructure under them, and today most of that work is AI: RAG pipelines, agentic workflows and the Python services that keep them running in production.
As a senior software engineer, I designed and owned the backend of a clinical trial AI platform, cutting narration time from 3 hours to 5 minutes. I also delivered RAG systems that reached 95% retrieval accuracy and RAG MVPs that halved client onboarding time. Now I work as a technical lead on AI projects, including a med-tech initiative built to HIPAA standards, and take on freelance engagements where I can own a problem end to end.
I build the frontend too, so a product doesn't stop at the API. I'm confident taking a web app from first screen to production, built to scale.
Away from the keyboard I'm usually on a motorcycle, in the gym, deep in a game or tinkering with some piece of creative tech that has no business plan at all.
Off hours
- motorcycles
- gaming
- fitness
- creative tech
- building things
- role
- forward deployed engineer
- now
- technical lead + freelance
- experience
- backend & devops, mostly ai today5+ years
- builds
- full-stack ai products
- cloud
- ~2y azure in prod[aws, gcp, azure]
- location
- Ahmedabad, India
- previously
- senior software engineer
- off_hours
- motorcycles
- gaming
- fitness
- creative tech
- building things
05Contact
Have a problem that needs to reach production?
Tell me what's slow, manual or stuck at prototype. I'll give you an honest read on whether I can help, and what the simplest version looks like.