Pravit Ampapathini
Go
Python
Model Architecture & Training: 6/10
Experimentation & Evaluation: 6/10
Computational Efficiency: 6/10
Active 1 day ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
Senior backend engineer specializing in production distributed task orchestration and reliable Go services. The strongest proven skill is designing and testing concurrent, transactional job orchestration infrastructure as shown by the distributed_task_queue package (worker runtime, Redis-ready lists, CockroachDB transaction retry, and extensive concurrency tests). Public code shows solid backend and ML-pipeline engineering but lacks evidence of full production-grade auth/token lifecycle, large-scale service mesh design, or extensive cloud infra/CI ownership.
Technical skills
Go• Senior
Python• Senior
Go
Go-redis
Python
FastAPI
Uvicorn
Requests
Pydantic
Databases
LanceDB
AI/ML
Deep Learning
LLM
Accelerate
TRL
Unsloth
Bitsandbytes
Datasets
Anthropic SDK
OpenAI SDK
Sentence-Transformers
Llama
PEFT
Senior AI/ML Engineer
Confidence: Medium ML Engineer
ML Engineer (senior-level practice) focusing on LLM fine-tuning and mechanistic interpretability with a strong practical emphasis on LoRA/SFT and activation-patching experiments. The strongest proven skill is building end-to-end LLM experiment and training pipelines, demonstrated by train_unsloth_sft.py (LoRA SFT, BitsAndBytes quantization) and the causal_patcher ExperimentRunner and viz tooling. Public work shows little evidence of production-grade telemetry/drift-monitoring, hardened multi-tenant serving, or large-scale distributed training orchestration in the code available here.
Model Architecture & Training
6/10
How well models are designed and trained
Model architecture and training engineering: custom SFT/LoRA training scripts, quantization and BitsAndBytes configs, and model-load / inference code for both HF and OpenAI backends.
Evidence
nomos-ai/scripts/train_unsloth_sft.py: SFTConfig usage and LoRA/Unsloth training orchestration
nomos-ai/backend/app/model_runner.py:_load — BitsAndBytesConfig, AutoModelForCausalLM.from_pretrained and device_map usage
nomos-ai/scripts/eval_unsloth_lora.py:_load_model_hf and _load_model_unsloth — loading adapters and PEFT/Unsloth plumbing
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Data pipeline and feature engineering: synthetic data generation, validation, embedding creation, and ingestion into LanceDB with payload shaping and provenance handling.
Evidence
nomos-ai/scripts/generate_synthetic_data.py: rows_to_lance_payloads, embed_batch and ingest_lance
nomos-ai/database/init_lancedb.py and database/client.py: init_legal_corpus_table, connect, list_table_names
Experimentation & Evaluation
6/10
How results are measured and tested
Experimentation and evaluation: structured baseline/patching experiments, evaluation harnesses, notebooks and unit tests that exercise baselines and patched runs.
Evidence
llm-scalpel/causal_patcher/runner.py: ExperimentRunner implementing baseline runs, caching, and patch_clean_into_corrupt
llm-scalpel/notebooks/demo_factual_recall.ipynb: end-to-end activation-patching demo and measurement
nomos-ai/scripts/eval_llm_judge.py and nomos-ai/scripts/eval_unsloth_lora.py: LLM evaluation harnesses and judgment pipelines
MLOps & Deployment
4/10
How models are shipped to production
MLOps and deployment basics: FastAPI endpoints, model loading lifecycle and status endpoints, plus artifact saving; limited production-grade serving and monitoring evidence.
Evidence
nomos-ai/backend/app/main.py: FastAPI app and audit endpoints (audit, health)
nomos-ai/backend/app/model_runner.py: ensure_loaded, inference_ready, status_snapshot for runtime diagnostics
pg-ai-submission/main.py: FastAPI webhook receiver for Vapi transcripts and recording downloads
Computational Efficiency
6/10
How efficiently computing resources are used
Computational efficiency: explicit 4-bit quantization, BitsAndBytes NF4 configs, device_map usage, and LoRA adapters to reduce footprint; attention to fp16/bf16 where applicable.
Evidence
nomos-ai/backend/app/model_runner.py:_load — BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_* and bnb_4bit_compute_dtype=torch.bfloat16)
nomos-ai/scripts/train_unsloth_sft.py: FastLanguageModel.from_pretrained(load_in_4bit=True), SFTConfig fp16/bf16 and training hyperparameter tuning
Research Depth & Innovation
6/10
Depth of research and new ideas
Research depth and innovation: original mechanistic-interpretability tooling (activation patching), plotting utilities and experiment runner enabling reproducible path-patching experiments.
Evidence
llm-scalpel/causal_patcher/runner.py: custom _patch_fn, patching control and baseline orchestration
llm-scalpel/causal_patcher/viz.py and notebooks/demo_factual_recall.ipynb: plotting and experimental demonstration of causal patching
Verified artifacts
Expertise
LLM• Senior
Industries
Artificial Intelligence• Middle
Software• Middle
Health Care• Middle
Technologies
Deep Learning
LLM
Recommendations
- Lead development of LLM fine-tuning and adapter workflows (LoRA/PEFT) including dataset curation and evaluation harnesses.
- Implement mechanistic-interpretability experiments and visualization tooling that integrates activation-patching with reproducible baselines.
- Build model evaluation and CI pipelines (evaluation runners, judge-call wrappers, reproducible synthetic data generation) for LLM-based compliance or audit systems.
- Package and harden FastAPI model-serving endpoints for inference, adding auth, observability and input validation for production readiness.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Medium ML Practitioner
ML practitioner specializing in fine-tuning, evaluation, and mechanistic interpretability with strong end-to-end model and inference engineering; senior-level practitioner in practical ML engineering. The strongest proven skill is building production-focused SFT and inference tooling, evidenced by scripts/train_unsloth_sft.py and backend/app/model_runner.py which handle quantized LoRA training, adapter management, and HF/OpenAI inference fallbacks. Public code shows limited formal statistical analysis, no large-scale distributed data engineering (Spark/Hadoop) or formal data-versioning (DVC) workflows, and minimal production CI/CD plumbing evidence.
Statistical Rigor
2/10
Correct use of statistics
Limited formal statistical rigor; experiments and metrics are pragmatic (logit diffs, micro-F1) with no hypothesis testing, uncertainty calibration, or multiple-comparison controls documented.
Data Wrangling & Cleaning
7/10
Preparing and cleaning data
Strong practical data wrangling and ingestion practices: explicit validation, fingerprinting, embedding pipeline, and LanceDB ingestion with defensive checks.
Evidence
pravit-amp/nomos-ai/scripts/generate_synthetic_data.py: validate_row, extract_json_array, rows_to_lance_payloads (embedding dim checks)
pravit-amp/nomos-ai/scripts/generate_synthetic_data.py: ingest_lance and write_health (LanceDB usage)
pravit-amp/nomos-ai/database/init_lancedb.py and database/client.py: table init and connect
Exploratory Analysis & Visualization
4/10
Exploring and visualizing data
Exploratory analysis is present and question-driven in mechanistic-interp work, with useful visualizations but limited narrative writeups and formal data-storytelling in scripts.
Predictive Modeling
6/10
Building models that predict
Clear competence in predictive-model workflows and model infra: fine-tuning (LoRA), quantized model loading, evaluation harnesses and inference wrappers; largely engineering-first with less evidence of rigorous model selection/CV experiments.
Evidence
pravit-amp/nomos-ai/scripts/train_unsloth_sft.py: SFT training loop using Unsloth, PEFT, BitsAndBytesConfig and SFTTrainer
pravit-amp/nomos-ai/backend/app/model_runner.py: HF quantized model loading, LoRA adapter handling, and OpenAI-generation fallback
pravit-amp/nomos-ai/scripts/eval_unsloth_lora.py: inference loop and prediction vs gold key micro-F1 calculation
Business Insight & Impact
3/10
Turning analysis into business value
Domain framing for regulatory compliance is explicit and concrete, but business-impact metrics, cost-sensitive error analysis, and operational KPIs are only lightly addressed.
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Reasonable reproducibility hygiene: pinned requirements, dotenv-driven config, deterministic seeds in training configs, and scripted save/load paths, though no DVC or full data-versioned pipelines are present.
Expertise
Analytics• Middle
Industries
Artificial Intelligence• Middle
Technologies
Python• Senior
Bitsandbytes
Sentence-Transformers
Anthropic SDK
OpenAI SDK
PEFT
TRL
Unsloth
Llama
Accelerate
Datasets
LanceDB
LLM• mentioned only
Recommendations
- Develop production SFT adapters and evaluation harnesses (LoRA quantized training, inference wrappers) including reproducible CI steps and model packaging.
- Implement embedding ingestion and small-scale vector DB pipelines (LanceDB) for search and downstream retrieval-augmented workflows.
- Prototype mechanistic interpretability experiments and visualizations (transformer-lens + SAE) to support model debugging and research.
- Build inference-serving glue and prompt-engineering tooling with secure model loading and fallback (OpenAI + HF) for audit-style inspection endpoints.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High Distributed Systems
Senior backend engineer specializing in production distributed task orchestration and reliable Go services. The strongest proven skill is designing and testing concurrent, transactional job orchestration infrastructure as shown by the distributed_task_queue package (worker runtime, Redis-ready lists, CockroachDB transaction retry, and extensive concurrency tests). Public code shows solid backend and ML-pipeline engineering but lacks evidence of full production-grade auth/token lifecycle, large-scale service mesh design, or extensive cloud infra/CI ownership.
API Design
4/10
How well APIs are designed
API design is pragmatic with well-covered HTTP handlers and integration tests, but lacks explicit idempotency key patterns or documented versioning strategy; error contracts are present but not uniformly formalized.
Evidence
distributed_task_queue/internal/orchestrator/api_read.go: taskToReadResponse (HTTP read shaping)
distributed_task_queue/internal/orchestrator/submit.go: SubmitTask (task submission semantics)
distributed_task_queue/internal/orchestrator/integration_api_test.go: end-to-end POST /v1/tasks and GET endpoints
Data Layer & Database
6/10
Working with databases
Strong evidence of deliberate data-layer decisions: single-statement status aggregation, explicit transaction retry/backoff and tests exercising serialization retry behaviour and stale-read hazards.
Evidence
distributed_task_queue/internal/db/retry.go: InTx, txRetryBackoff and IsSerializationFailure (transaction retry logic)
distributed_task_queue/internal/db/jobs.go: RefreshJobStatus single-statement aggregation to avoid stale-read races
distributed_task_queue/internal/db/jobs_concurrency_test.go: TestRefreshJobStatus_StaleReadCannotWinTheLastWrite (concurrency test covering DB invariants)
Scalability & Performance
6/10
Handling load and speed
Clear focus on scalable queue-based architecture with Redis-ready lists, scheduled ZSET, worker leases, and reclaim logic; good use of concurrency primitives and tests for delivery semantics.
Evidence
distributed_task_queue/internal/worker/runtime.go: Run, runLoop, heartbeatLease, SetLease/ReleasePending orchestration
distributed_task_queue/internal/redis/ (keys.go, queue.go, scheduled.go): ReadyList, EnqueueTaskIDs, ScheduledZSet, DueTaskIDs
distributed_task_queue/internal/orchestrator/reconcile.go and reclaim.go: ReconcileOnce, ReclaimStaleRunningTask (scheduler/reconciliation paths)
System Architecture
5/10
Overall system structure
Module boundaries and service decomposition are sensible (orchestrator, worker, db, redis, pkg/worker runtime). The design is production-minded but not a multi-service microservice mesh with cross-service contracts.
Evidence
distributed_task_queue/cmd/orchestrator/main.go and cmd/worker/main.go: separate runtime entry points
distributed_task_queue/pkg/worker and internal/worker/runtime.go: clear runtime / handler abstraction
project layout and README: separated internal/, pkg/, cmd/ structure documenting roles
Security & Auth
2/10
Protecting data and access
Some basic input validation and environmental checks exist, but no strong evidence of comprehensive authn/authz, token lifecycle, or dependency-audit automation; there are also risky patterns in ML code (remote code trust) that reduce security posture.
Evidence
nomos-ai/backend/app/main.py: environment checks and Pydantic usage for request models
pg-ai-submission/run_evals.py and main.py: _load_config requiring env secrets and error handling
nomos-ai/backend/app/model_runner.py: uses trust_remote_code=True when loading HF models (security risk)
Reliability & Observability
6/10
Stability and monitoring
Reliability and observability are well represented: retries, backoff, timeouts, graceful shutdown patterns, heartbeats, and test coverage for reclamation and concurrency; Prometheus client usage indicates metrics exposure.
Evidence
distributed_task_queue/internal/db/retry.go: txRetryBackoff and retry semantics
distributed_task_queue/internal/worker/runtime.go: Run with ctx cancellation and graceful wait; heartbeat and lease refresh with timeouts
distributed_task_queue/internal/orchestrator/metrics.go: MetricsHTTPHandler and MetricsMiddleware (Prometheus integration)
Expertise
Go Development• Senior
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Python• Middle
Technologies
Go• Senior
FastAPI
Pydantic
Uvicorn
Go-redis
Requests
Recommendations
- Develop production task orchestration and worker runtimes that require strong DB transaction patterns, lease/lease-renewal and exactly-once delivery semantics.
- Implement or extend high-throughput job schedulers, background processing systems, and real-time queue-based services using Go and Redis/CockroachDB.
- Build model-inference and data-pipeline tooling for LLM-powered products (FastAPI endpoints, prompt pipelines, embedding ingestion into vector stores) given ML pipeline and Python LLM experience.
- Owner for reliability improvements: transactional retry strategies, observability (metrics/alerts), and chaos-tested reclaim/resilience scenarios.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: