Aniket Jaswal
Python Developer
C++
Python
SQL
JavaScript
Node JS
C#
Ruby
PHP
C
Data Pipeline & Feature Engineering: 5/10
MLOps & Deployment: 4/10
Research Depth & Innovation: 4/10
Active 1 day ago
+62 (805) 66407 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Senior backend engineer focused on API-driven AI systems with a strength in building auditable RAG and retrieval components. The strongest proven skill is building reliable retrieval-to-LLM pipelines and observability hooks, demonstrated by the HybridRetriever/llm_client/guardrail flow and the unified JSON logging with request_id propagation. Public code does not show formal test suites, advanced operational runbooks, or explicit token-revocation and lifecycle machinery.
Technical skills
C++
Python• Senior
SQL
JavaScript
Node JS
C#
Ruby
PHP
C
Python
Pydantic
SQLAlchemy
Uvicorn
Alembic
HTTPX
Requests
Beautiful Soup
Django REST Framework• 3y+
FastAPI• 3y+
Celery
Django
PHP
Laravel
Databases
MySQL
Pinecone
Redis
Weaviate
Chroma
PostgreSQL• 3y+
AI/ML
Claude
Cohere SDK
CrewAI
Fine-tuning
Function Calling
Gemini
LlamaIndex
LLM
Prompt Engineering
RAG
Spark
Transformers
Groq
LangChain
AI Agents
DevOps
Amazon EC2
AWS Lambda
Azure
CI/CD
Docker
GitLab CI
Jenkins
Kubernetes
Rest API
SLI/SLO/SLA
Vector
Docker Compose
Containers
AWS• 3y+
Cloudflare• 3y+
WebSockets• 3y+
Git
Frontend
Bootstrap
Redux
Tailwind CSS
Vue.js
PostCSS
React.js• 3y+
QA
Postman
Pytest
Swagger
Mobile
Firebase
React Native• 3y+
Analytics
Power BI
Timeline
Associate Developer
•
Middle
Weaddo
•
Full-Time
Built an end-to-end workflow management system with FastAPI and Celery, including role-driven approval chains and async task dependencies that reduced brand asset cycle time by 40%. Integrated an LLM smart tagging module using OpenAI API and LangChain to auto-classify 10,000+ assets, cutting manual effort by 70%. Developed REST integrations between DAM and PIM for Ageasy with FastAPI and data modeling using Django ORM/PostgreSQL, improving processing speed and reducing onboarding errors. Implemented OAuth 2.0 integrations for Google Drive and OneDrive to support secure authentication and bulk ingestion.
FastAPI
Celery
LangChain
React.js
Django
PostgreSQL
Full Stack Developer
•
Middle
DWS
•
Full-Time
Re-engineered a multi-restaurant ordering platform using Django REST Framework and FastAPI microservices with a React.js frontend, improving page load and scaling for higher peak concurrency. Optimized delivery partner geocoding with async Python and FastAPI, reducing incorrect assignments and lowering third-party API costs. Led cloud migration of media assets to AWS S3 and Cloudflare R2 via Django Storages, cutting storage costs and improving delivery speed. Delivered real-time sports features with WebSockets and built mobile functionality using React Native, including AI match summary generation and a secure loan system using FastAPI, PostgreSQL, and Firebase OTP.
Django REST Framework
FastAPIsince 2023
React.jssince 2023
AWS
Cloudflare
WebSockets
React Native
PostgreSQLsince 2023
Thapar University
Bachelor's Degree •
Computer Engineering
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
LLM-focused engineer (senior level) who builds production-oriented RAG/agent systems with attention to observability and reliability. The strongest proven skill is architecting evidence-grounded retrieval and agent pipelines with guardrails, as shown by the HybridRetriever, evidence-constrained synthesizer, and guardrail faithfulness checks. Public code does not show custom model training, formal experiment tracking (W&B/MLflow), or GPU/quantization optimizations for model efficiency.
Model Architecture & Training
2/10
How well models are designed and trained
No custom model training or optimization; evidence of embedding strategy and inference wrappers but not training pipelines or advanced model tuning.
Evidence
specpilot/ingest/retriever.py:_SentenceTransformerEmbedder and _TfidfEmbedder (embedder backends and embedder selection)
clientiq/backend/app/services/vector_store.py:HashingEmbeddingFunction (custom lightweight embedding function)
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Solid data ingestion and feature preparation: chunking, hybrid retrieval (BM25 + dense), multiple MCP connectors, scrapers and seed data for pipelines.
Evidence
specpilot/ingest/chunker.py:Chunk parsing and load_corpus (corpus chunking)
specpilot/ingest/retriever.py:HybridRetriever.retrieve (BM25 + dense ensembling and normalization)
hotel_booking_review_dashboard/backend/app/scraper/booking_scraper.py:BookingScraper.scrape_reviews (robust external data ingestion and normalization)
Experimentation & Evaluation
2/10
How results are measured and tested
Basic instrumentation and deterministic mocks allow offline runs and lightweight evals but no full experiment tracking, structured runs, or A/B frameworks.
Evidence
specpilot/logs/logger.py:timed_node and summarize_run instrumentation (token/latency logging)
specpilot/llm_client.py:MockLLM (deterministic offline behavior for pipeline testing)
MLOps & Deployment
4/10
How models are shipped to production
Clear deployment-ready components (FastAPI endpoints, Streamlit UI, Celery tasks, Alembic migrations, Chroma persistence) but limited evidence of production-grade serving (autoscaling, drift monitoring, CI/CD pipelines).
Evidence
specpilot/serve/api.py:FastAPI endpoints and Pydantic models (service surface)
hotel_booking_review_dashboard/backend/app/tasks/scraper.py:Celery tasks (background scraping and task lifecycle)
hotel_booking_review_dashboard/backend/alembic/versions/e59651b0c325_initial_schema.py:Alembic migrations (schema management)
Computational Efficiency
3/10
How efficiently computing resources are used
Pragmatic efficiency choices (hashing embedding to avoid heavy deps, choosing GROQ for latency) but no GPU profiling, quantization, batching improvements or explicit memory optimizations.
Evidence
clientiq/backend/app/services/vector_store.py:HashingEmbeddingFunction (dependency-free embedding to avoid model downloads)
specpilot/llm_client.py:GroqLLM choice and MockLLM fallback (latency-aware LLM selection)
Research Depth & Innovation
4/10
Depth of research and new ideas
Good applied research/design work around retrieval-ensembling, reliability guardrails, contradiction detection and evidence-grounded synthesis, but not novel algorithmic contributions or published reproduction of papers.
Evidence
specpilot/agents/guardrail.py:guardrail_node (faithfulness scoring and deterministic citation checks)
specpilot/agents/synthesizer.py:synthesize_node (evidence-constrained synthesis with explicit citation requirements)
Expertise
AI Agents & Agentic Workflows• Senior
RAG• Middle
Industries
Telecommunications• Senior
Travel & Tourism• Middle
Technologies
SQL
C++
MySQL
PostgreSQL• 3y+
Redis
Weaviate
Rest API
LangChain
Claude
Spark
Chroma
Pinecone
Groq
LlamaIndex
WebSockets• 3y+
Fine-tuning
Prompt Engineering
Function Calling
Cohere SDK
GitLab CI
Azure
CI/CD
Jenkins
Transformers
Git
AWS• 3y+
Docker
Kubernetes
CrewAI
Cloudflare• 3y+
Gemini
LLM
RAG
HTTPX
Uvicorn
Django REST Framework• 3y+
Alembic
AWS Lambda
Amazon EC2
Vector
SLI/SLO/SLA
Copilot• mentioned only
LangGraph• mentioned only
Python• mentioned only
Vector• mentioned only
Recommendations
- Develop production RAG agents with auditable reliability layers and citation-traceability for regulated domains.
- Build and maintain enterprise data connectors and ingestion pipelines (MCP-style connectors) that feed vector stores and agents.
- Instrument and extend LLM ops: structured experiment tracking, cost/latency budgets, and drift/health monitoring for LLM-driven features.
- Implement efficiency improvements for inference (quantization, batching, profiling) and add end-to-end CI/CD for model/service deployment.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
Senior backend engineer focused on API-driven AI systems with a strength in building auditable RAG and retrieval components. The strongest proven skill is building reliable retrieval-to-LLM pipelines and observability hooks, demonstrated by the HybridRetriever/llm_client/guardrail flow and the unified JSON logging with request_id propagation. Public code does not show formal test suites, advanced operational runbooks, or explicit token-revocation and lifecycle machinery.
API Design
4/10
How well APIs are designed
Clear, consistent FastAPI route layout and dependency middleware with request-context propagation and auth hooks, but no visible versioning, idempotency keys, or explicit pagination conventions across endpoints.
Evidence
clientiq/backend/app/api/deps.py: RequestContextMiddleware and get_current_user
clientiq/backend/app/api/routes_analysis.py: ask, history, get_by_id endpoints using dependencies
clientiq/backend/app/api/routes_auth.py: login endpoint with token creation
Data Layer & Database
4/10
Working with databases
Reasonable data-layer practices with Alembic migrations and SQLAlchemy models, uniqueness/indexes and duplicate-detection, but limited explicit transaction handling or isolation-level considerations.
Evidence
hotel_booking_review_dashboard/backend/alembic/versions/e59651b0c325_initial_schema.py: initial schema and indexes
hotel_booking_review_dashboard/backend/app/tasks/scraper.py: uses IntegrityError handling when inserting reviews
hotel_booking_review_dashboard/backend/scripts/seed_data.py: DB seeding using SQLAlchemy SessionLocal
Scalability & Performance
4/10
Handling load and speed
Scalability-minded choices present - background jobs (Celery), HTTP client timeouts, caching for AI recommendations, and a custom lightweight embedding to avoid heavy downloads - but no advanced load-testing, sharding, or cache invalidation strategy shown.
Evidence
hotel_booking_review_dashboard/backend/app/tasks/scraper.py: Celery background tasks for scraping and analysis
clientiq/backend/app/services/vector_store.py: HashingEmbeddingFunction to avoid heavy model downloads
clientiq/backend/app/services/analytics.py: RECOMMENDATION_CACHE with TTL used to avoid repeated AI calls
System Architecture
5/10
Overall system structure
Deliberate modular architecture with clear module boundaries (MCP connectors, LangGraph nodes, services, API, logging template) and an orchestrated LangGraph pipeline, showing thought in decomposition and observability integration.
Evidence
clientiq/backend/app/agents/graph.py: LangGraph orchestration and compiled graph
clientiq/backend/app/agents/nodes.py: separated node implementations for each data source
clientiq/backend/app/core/logging_config.py: central logging template and request_id propagation
Security & Auth
4/10
Protecting data and access
Basic security primitives and auth are present - JWT creation/verification, password hashing and FastAPI OAuth deps - but token lifecycle, revocation, and advanced boundary hardening are not visible in code excerpts.
Evidence
clientiq/backend/app/core/security.py: create_access_token, decode_access_token, passlib/jose imports
clientiq/backend/app/api/deps.py: OAuth2PasswordBearer and get_current_user dependency
clientiq/backend/app/models/schemas.py: pydantic schemas for request/response validation
Reliability & Observability
5/10
Stability and monitoring
Strong observability and reliability focus with structured JSON logging, request_id correlation, timers, and an LLM guardrail layer; standard graceful-shutdown and advanced retry/backoff patterns are not broadly present in the inspected code.
Evidence
clientiq/backend/app/core/logging_config.py: JsonFormatter, set_request_id, Timer, log_event
specpilot/agents/guardrail.py: faithfulness guardrail that enforces result refusal on low score
specpilot/logs/logger.py: instrumentation helpers and run summarization
Verified artifacts
Expertise
Backend AI & LLM• Senior
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Python• Middle
Industries
Telecommunications• Senior
Travel & Tourism• Middle
Technologies
PHP
Laravel
Vector• mentioned only
Recommendations
- Design and build production-grade RAG pipelines and LLM orchestration with observability and guardrails - implement new retrieval adapters or LLM integrations.
- Develop backend APIs and connector integrations for enterprise data sources (Postgres, Salesforce, Slack, Google Sheets) including robust error handling and idempotent job processing.
- Implement DB migration strategies and data integrity work - extend Alembic migration history and add transactional isolation testing and schema evolution tooling.
- Build background processing and ML feature pipelines using Celery or equivalent, adding retries with exponential backoff, monitoring, and graceful shutdown handling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle DevOps Engineer
Confidence: Medium Generalist
Full-stack Python engineer (Middle) focused on building resilient web APIs and background-job pipelines. The strongest proven skill is reliable background processing and scraping, evidenced by app/tasks/scrape_job.py with Playwright fallback and the Celery task decorator configuring autoretry_for and retry_backoff. There is limited public evidence of CI/CD pipelines, infrastructure-as-code (Terraform/remote state), formal observability (metrics/SLOs/alerting), or automated tests.
CI/CD Pipelines
Automated build and deploy
Not evidenced in public code
Infrastructure as Code
1/10
Managing servers with code
Basic local infra artifacts (Dockerfile and docker-compose) exist but there are no versioned IaC modules, remote state, or state migration practices.
Containerization & Orchestration
2/10
Working with containers
Containerization is used for local/dev (Dockerfile + docker-compose) but there are no multi-stage builds, non-root user configuration, Kubernetes manifests, resource requests/limits, PDBs, or operators.
Observability & Monitoring
1/10
Watching system health
Minimal observability: there are health/test endpoints and some debug prints but no metrics, dashboards as code, SLOs, alert routing, or noise reduction shown.
Reliability & Incident Response
4/10
Keeping systems up
Application-level reliability practices are present: Celery task retries with backoff, synchronous fallback when Redis is unavailable, request timeouts and Playwright fallback, and careful error handling around scraping and email jobs.
Evidence
Anniedrippin/job_tracker/app/tasks/scrape_job.py - Playwright fallback, request timeouts, route handler aborting heavy resources, scrape_job Celery task with autoretry_for and retry_backoff
Anniedrippin/job_tracker/app/api/routes.py - is_redis_available fallback to synchronous scrape_job_now when Redis/Celery is unreachable
Anniedrippin/job_tracker/app/tasks/reminders.py - Celery beat schedule and tasks with SMTP guard
Cloud & Cost Optimization
1/10
Smart use of the cloud
Small cloud-aware hints (DATABASE_URL, Render hostname) exist in settings but there is no demonstrated autoscaling, cost strategies, spot handling, workload identity, or IAM least-privilege patterns.
Expertise
Site Reliability Engineering• Middle
Technologies
Containers
Python• Senior
Docker Compose
SQLAlchemy
FastAPI• 3y+
Beautiful Soup
Django
Celery
Pydantic
Requests
Recommendations
- Use to build and extend REST APIs and background-job pipelines where reliability and retry behavior matter (work on scraping, ETL, scheduled tasks).
- Have this developer harden observability and SRE practices by adding metrics, Prometheus/Alertmanager instrumentation, and SLO-based alerts built from app/tasks/* and API endpoints.
- Assign to implement CI/CD and IaC for deployments (GitHub Actions / Terraform or CDK), and to add secure secrets handling for runtime credentials.
- Engage to productionize container deployments (Kubernetes manifests, resource requests/limits, readiness/liveness probes) and to design graceful shutdown and rollout strategies.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: