Hiya Arora
Software Developer
JavaScript
TypeScript
Python
SQL
Data Pipeline & Feature Engineering: 6/10
Experimentation & Evaluation: 6/10
MLOps & Deployment: 5/10
Active 2 days ago
+91 (9466) 326125
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A Senior-level backend engineer focused on building production-ready systems for retrieval and LLM-backed services with strong test coverage and integration discipline. The most proven skill is designing and testing a retrieval + embedding + vectorstore pipeline with concrete artifacts in the retrieval modules and the embedding/vectorstore abstractions (e.g. app/retrieval/*, app/embeddings/*, app/vectorstore/*). What is not evidenced publicly is large-scale service operating history, dedicated load-testing data, or advanced platform-level automation such as production-grade orchestrated microservice deployments.
Technical skills
JavaScript
TypeScript
Python• Senior
SQL• Junior
Python
Asyncio
FastAPI
Flask
Pydantic
Alembic
Beautiful Soup
SQLAlchemy
HTTPX
Requests
Databases
MySQL
Databases
MongoDB
pgvector
PostgreSQL
AI/ML
Gemini
Keras
Semantic Search
Streamlit
TensorFlow
Google GenAI SDK
Groq
AI Agents
Embeddings
RAG
LangChain
LLM
NLP
Prompt Engineering
Frontend
React.js
Tailwind CSS
PostCSS
DevOps
AWS
Docker
Vector
CI/CD
Jenkins
Rest API
Git
Timeline
Software Engineer
•
Middle
Salescode.ai
•
Full-Time
Worked on backend services and API workflows using Python and SQL, integrating multi-application systems via REST APIs. Built Python automation and Jenkins-based CI workflows, improving automation coverage and adding large numbers of automated checks for client deployments. Evaluated AI agent workflows for high-volume voice interactions for FMCG clients. Developed RAG pipelines using embedding models with PGVector to deliver accurate, low-latency AI responses.
Python
SQL
Rest API
Jenkins
CI/CD
pgvector
PostgreSQL
Embeddings
RAG
AI Agents
Guru Gobind Singh Indraprastha University (GGSIP University)
Bachelor's Degree •
Information Technology
Research Intern
•
Junior
DRDO (SAG)
•
Internship
Researched artificial neural networks for multi-class image classification, including a digit recognition implementation on the MNIST dataset with preprocessing and normalization. Explored convolutional neural networks for image classification and studied convolution, pooling, and batch-based training and evaluation. Analyzed overfitting and generalization using training and validation performance and investigated dropout and batch normalization for model optimization.
Senior AI/ML Engineer
Confidence: High LLM Engineer
LLM engineering specialist (senior-level) focused on production retrieval-augmented systems and reliable document ingestion pipelines. The strongest proven skill is building measurement-driven retrieval and evaluation pipelines, evidenced by backend/app/retrieval/* and backend/app/eval/* (including embedding_cache, metrics, and integration tests). There is little to no public evidence of custom model training (no custom architectures or distributed training code) or low-level GPU/quantization work.
Model Architecture & Training
2/10
How well models are designed and trained
Integration of hosted LLMs and embedding providers is well engineered, but there is no evidence of custom model architectures, training loops, or optimizer/scheduler design.
Evidence
backend/app/llm/gemini.py: GeminiProvider streaming and configuration
Jira-Assisant-AI/src/qa_jira/ai/base.py: parse_json_loose and complete_json helpers
Data Pipeline & Feature Engineering
6/10
How data is prepared for models
Robust document ingestion and preprocessing pipeline with careful chunking, OCR gating, table rendering and multiple parsers; shows deliberate design to preserve page boundaries and handle many input types.
Evidence
backend/app/ingestion/chunking.py: split_text and chunk_pages logic
backend/app/ingestion/pdf.py: PdfParser with OCR fallbacks
backend/app/ingestion/tabular.py: XlsxParser/CsvParser and table rendering
Experimentation & Evaluation
6/10
How results are measured and tested
Strong evaluation and experiment tooling: golden datasets, deterministic offline evals, embedding cache, and test suites that exercise end-to-end measurement and thresholds.
Evidence
backend/app/eval/metrics.py: retrieval metrics (recall@k, MRR, nDCG)
backend/app/eval/embedding_cache.py: disk-backed embedding cache for repeatable measurement
job-application-tracker/jobagent/evals.py: deterministic scoring, caching and report generation
MLOps & Deployment
5/10
How models are shipped to production
Solid MLOps and deployment engineering: vectorstore integration, archiving/restore semantics, migrations, and deploy docs; thoughtful lifecycle and failure handling are present.
Evidence
backend/app/vectorstore/chroma.py: ChromaVectorStore wrapper and error handling
backend/app/services/document_lifecycle_service.py: archive/restore/purge and batched upsert
backend/alembic/env.py and alembic/versions: database migrations
Computational Efficiency
5/10
How efficiently computing resources are used
Measured efficiency work is present in batching, caching, and test doubles; there is attention to embedding batching and avoiding unnecessary external calls, but no low-level GPU/quantization optimizations.
Evidence
backend/app/services/document_lifecycle_service.py: batched embedding re-embed in restore_document using settings.embedding_batch_size
backend/app/eval/embedding_cache.py: persistent caching to avoid re-embedding during repeated runs
Research Depth & Innovation
5/10
Depth of research and new ideas
Good research-aware engineering: hybrid retrieval, reciprocal rank fusion, marker-based golden labels, and calibrated thresholds derived from measurement; this is applied ML engineering rather than novel research.
Evidence
backend/app/retrieval/fusion.py: reciprocal_rank_fusion implementation
backend/app/eval/dataset.py: marker-based golden-set design and validation
backend/app/retrieval/pipeline.py: calibrated retrieval gating and evaluation-aware design
Verified artifacts
Expertise
RAG• Senior
LLM• Senior
MLOps & Model Lifecycle• Senior
Document Intelligence & OCR• Middle
Industries
Artificial Intelligence• Senior
Software• Middle
Technologies
Databases
SQL• Junior
MySQL
Rest API
pgvector
Flask
Embeddings
Prompt Engineering
AI Agents
NLP
Google GenAI SDK
CI/CD
Jenkins
TensorFlow
Keras
Git
AWS
Docker
Gemini
RAG
Vector
Semantic Search
Python• mentioned only
Recommendations
- Design and implement production RAG services that include threshold calibration, A/B evaluation, and embedding caching.
- Build or harden retrieval/reranker integration and end-to-end eval dashboards (metric tracking and per-query failure analysis).
- Implement document ingestion pipelines for varied formats with robust OCR and table extraction, and add monitoring for ingestion quality and drift.
- Operationalize vectorstore lifecycle and restoration flows (backup, restore, graceful reindexing, and drift detection).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Medium Data Engineer
A Senior data engineer specializing in LLM-backed retrieval and ingestion pipelines with a focus on reliability and measurable retrieval quality. The strongest proven skill is building robust RAG infrastructure and evaluation harnesses, evidenced by the retrieval pipeline, evaluation harness and metric tests (app/retrieval/*, app/eval/*, tests/test_eval_metrics.py). There is limited evidence of classical statistical inference, model training, or formal data-versioning workflows in the public human-authored code.
Statistical Rigor
2/10
Correct use of statistics
Minimal statistical inference practice. The code contains careful evaluation metrics for retrieval, but no explicit hypothesis testing, uncertainty quantification, or multiple-comparison controls.
Data Wrangling & Cleaning
7/10
Preparing and cleaning data
Strong data ingestion and cleaning discipline with explicit edge-case handling, deduplication, OCR gating, chunking, and robust lifecycle management for derived indexes.
Evidence
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
Some presentation-focused visualizations and UIs exist, but limited exploratory data analysis or narrative EDA steps; UI code is polished but not used as analytical reasoning documentation.
Predictive Modeling
3/10
Building models that predict
Practitioner-level use of LLMs and agent chains with tool-calling and streaming, but no evidence of training, feature engineering for classical models, or careful ML model evaluation beyond integration tests.
Business Insight & Impact
5/10
Turning analysis into business value
Product-aware engineering that links retrieval quality to user safety and business impact; retrieval thresholds and evaluation harness are explicitly justified in comments and code.
Reproducibility & Notebook Hygiene
6/10
Clean, repeatable analysis
Good reproducibility practices in tests and fixtures, deterministic test doubles, and clear test isolation strategies, though no evidence of data-versioning or pinned environment lockfiles in the analyzed human-authored files.
Expertise
Analytics• Senior
Streaming• Middle
Industries
Artificial Intelligence• Senior
Financial Services• Middle
Technologies
Python• Senior
MongoDB
PostgreSQL
LangChain
Groq
FastAPI
Beautiful Soup
LLM
Streamlit
Pydantic
Requests
Llama• mentioned only
Recommendations
- Develop production-grade vector-store adapters and multi-process cache invalidation for embeddings and show invariants with integration tests.
- Build a small evaluation notebook or report documenting calibration runs and sensitivity analysis for retrieval thresholds (linking eval harness outputs to decisions).
- Add data-versioning or dataset provenance (DVC or metadata) for the golden evaluation set and produced embeddings to improve reproducibility of A/B runs.
- Harden tool-call scraping with politeness (rate limits, robots.txt) and add retry/backoff policies and circuit-breakers for web scraping tools
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
A Senior-level backend engineer focused on building production-ready systems for retrieval and LLM-backed services with strong test coverage and integration discipline. The most proven skill is designing and testing a retrieval + embedding + vectorstore pipeline with concrete artifacts in the retrieval modules and the embedding/vectorstore abstractions (e.g. app/retrieval/*, app/embeddings/*, app/vectorstore/*). What is not evidenced publicly is large-scale service operating history, dedicated load-testing data, or advanced platform-level automation such as production-grade orchestrated microservice deployments.
API Design
6/10
How well APIs are designed
API design is deliberate and consistent with well tested error contracts, auth flows, and CLI-friendly payload shapes, but versioning and advanced idempotency patterns are not prominently documented.
Evidence
Hiyaarora/Atlas-ai/backend/app/api/v1/routes/auth.py: auth endpoints and refresh/login flows
Hiyaarora/Jira-Assisant-AI/src/qa_jira/jira_client.py: careful REST write paths and fallback strategies for create_bug/create_task
Hiyaarora/Atlas-ai/backend/app/core/exceptions.py and Hiyaarora/Atlas-ai/backend/tests/test_error_contract.py: centralized error envelope and tests
Data Layer & Database
7/10
Working with databases
Strong evidence of careful schema and transactional reasoning, migration tests, and atomic update patterns; explicit migration history and test harness show production-oriented DB work.
Evidence
Hiyaarora/Atlas-ai/backend/alembic/versions/*: multiple migration files (schema evolution)
Hiyaarora/Atlas-ai/backend/tests/test_migrations.py: tests asserting migrations match models
Hiyaarora/Atlas-ai/backend/app/services/document_lifecycle_service.py: atomic reference_count recompute using subquery and update
Scalability & Performance
6/10
Handling load and speed
Performance-aware design with caching, batching, async calls and vector-store abstractions; some cache/invalidation and batching strategies are present though no load-test artefacts or measured tuning are published.
Evidence
Hiyaarora/Atlas-ai/backend/app/eval/embedding_cache.py: disk-backed embedding cache rationale and implementation
Hiyaarora/Atlas-ai/backend/app/services/document_lifecycle_service.py: embedding batching on restore (embedding_batch_size)
Hiyaarora/Atlas-ai/backend/app/vectorstore/chroma.py: vectorstore abstraction and delete/upsert methods
System Architecture
7/10
Overall system structure
Clear module boundaries and deliberate decomposition (api, services, retrieval, llm, vectorstore) with test fixtures that validate integration boundaries; architecture choices are reasoned rather than accidental.
Evidence
Hiyaarora/Atlas-ai/backend/app/retrieval/*: retrieval pipeline split into lexical, dense, fusion and rerank modules
Hiyaarora/Atlas-ai/backend/app/llm/factory.py and app/llm/*: provider factory pattern and pluggable LLM providers
Hiyaarora/Atlas-ai/backend/app/main.py and app/jobs/maintenance.py: app lifecycle and background maintenance jobs
Security & Auth
6/10
Protecting data and access
Good attention to authentication, token handling and secrets checks with unit tests for token behaviour; some best-practice concerns remain (e.g. local temp file handling in a few places).
Evidence
Hiyaarora/Atlas-ai/backend/app/core/security.py and Hiyaarora/Atlas-ai/backend/tests/test_security.py: password hashing, JWT and refresh token tests
Hiyaarora/Jira-Assisant-AI/src/qa_jira/jira_client.py: basic_auth_header and careful HTTP error handling
Hiyaarora/Atlas-ai/backend/app/core/config.py: refusal of unsafe production defaults
Reliability & Observability
6/10
Stability and monitoring
Structured logging, request id propagation, failure injection in tests, and defensive maintenance code indicate solid observability and reliability practice; retry/circuit-breaker patterns exist in places but are not universally applied with measured backoff strategies.
Evidence
Hiyaarora/Atlas-ai/backend/app/core/logging.py and Hiyaarora/Atlas-ai/backend/app/middleware/request_context.py: structured logging and request id propagation
Hiyaarora/Atlas-ai/backend/tests/conftest.py: failure injection fixtures and test isolation for degraded dependencies
Hiyaarora/Atlas-ai/backend/app/embeddings/gemini.py: embed retry logic and exception classification
Expertise
Backend AI & LLM• Senior
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Industries
Artificial Intelligence• Senior
Software• Middle
Technologies
SQLAlchemy
Asyncio
HTTPX
Alembic
Recommendations
- Develop RAG and LLM-backed backend services, including retrieval pipelines, embedding integration and vectorstore adapters.
- Build and maintain API-first platform features such as auth, token lifecycle, and robust error contracts for CLI and web clients.
- Author evaluation harnesses and deterministic test suites for ML/LLM components and embed caching logic.
- Implement database schema evolution and lifecycle jobs that require careful transaction design and referential integrity handling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: