Arthur Damer
AI Engineer
Python
Node JS
SQL
PowerShell
Bash
Experimentation & Evaluation: 6/10
Model Architecture & Training: 5/10
Data Pipeline & Feature Engineering: 5/10
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
An LLM-focused engineer with solid, production-oriented ML/LLM engineering experience at a lower-end Senior level. The strongest proven skill is building and evaluating retrieval-augmented systems and LLM orchestration - evidenced by the RAG graph (grade/rewrite/verify), Store/Qdrant integration and the evaluation harness. There is limited evidence of full-scale MLOps (monitoring, drift detection, CI/CD for models) and no industrial-scale distributed training or custom CUDA kernels in public code.
Phone
Technical skills
Languages
5
Python
Node JS
SQL
PowerShell
Bash
Python
6
HTTPX
Beautiful Soup
Asyncio
FastAPI
Requests
python-telegram-bot
AI/ML
9
LLM
Claude
Transformers
Scikit-learn
LangGraph
PEFT
FastEmbed
Claude Code
RAG
Databases
3
Qdrant
SQLite
PostgreSQL
DevOps
7
Kubernetes
Docker
GitHub Actions
K3s
Rest API
ArgoCD
GitLab CI
Other
11
Pytest
React.js
Chart.js
pre-commit
ChatGPT
Helm
MS SQL
GitOps
Vite
CI/CD
Vector
Timeline
AI / Python Automation Engineer
•
Middle
Freelance
•
Freelance
Worked on an e-commerce automation system in Thailand consisting of about 20 production services. Built LLM-based task pipelines and headless agents that classify messages, execute backlog technical tasks with safety checks, and automate customer interactions. Implemented GitOps deployment to Kubernetes (k3s) using Docker/CI with monitoring and reporting, including RAG over documentation with Qdrant and fast embeddings.
Asyncio
HTTPX
Docker
Kubernetes
K3s
ArgoCD
Helm
GitOps
GitLab CI
SQLite
Beautiful Soup
Pytest
pre-commit
Claude Code
LLM
RAG
Qdrant
FastEmbed
GitHub Actions
Rest API
Claude
Junior Developer
•
Junior
Temir Tulpaar Asia
•
Full-Time
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
An LLM-focused engineer with solid, production-oriented ML/LLM engineering experience at a lower-end Senior level. The strongest proven skill is building and evaluating retrieval-augmented systems and LLM orchestration - evidenced by the RAG graph (grade/rewrite/verify), Store/Qdrant integration and the evaluation harness. There is limited evidence of full-scale MLOps (monitoring, drift detection, CI/CD for models) and no industrial-scale distributed training or custom CUDA kernels in public code.
Model Architecture & Training
5/10
How well models are designed and trained
Practical model training and architecture choices: LoRA/PEFT fine-tuning, masked-label training formulation, and a local classification path that scores label token probabilities.
Evidence
finetune-vs-prompt/fvp/train.py:_build_example
finetune-vs-prompt/fvp/train.py:train
finetune-vs-prompt/fvp/model.py:LocalClassifier
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Reasonable data pipelines and document chunking for retrieval, dataset splitting and cleaning for the finetune experiments.
Evidence
artirain-rag/rag/ingest.py:chunk_text
finetune-vs-prompt/fvp/data.py:load_splits
artirain-rag/eval/build_dataset.py:collect_chunks / parse_batch usage
Experimentation & Evaluation
6/10
How results are measured and tested
Honest evaluation harnesses with held-out splits, per-class metrics, latency measurement and result summarization; retrieval and answer-level judging pipelines are present.
Evidence
finetune-vs-prompt/eval/run_eval.py:evaluate
finetune-vs-prompt/eval/summarize.py:main
artirain-rag/eval/run_eval.py:eval_retrieval
MLOps & Deployment
4/10
How models are shipped to production
Lightweight serving and ops: FastAPI app, ingestion at startup, Qdrant-backed store abstraction and a rate limiter - suitable for demos and small services but not a full production MLOps stack.
Evidence
artirain-rag/rag/api.py:FastAPI endpoints and startup ingest
artirain-rag/rag/store.py:Store class (Qdrant integration)
artirain-rag/rag/ratelimit.py:RateLimiter
Computational Efficiency
5/10
How efficiently computing resources are used
Conscious efficiency choices: PEFT/LoRA adapters to avoid full-model fine-tuning, fp16 when CUDA available, lru_cache on embedders, retrieval prefetch/rerank strategy.
Evidence
finetune-vs-prompt/fvp/train.py:TrainingArguments(fp16, gradient_accumulation_steps)
finetune-vs-prompt/fvp/model.py:device/dtype selection and lru_cache pattern
artirain-rag/rag/store.py:prefetch factor and rerank() with a cross-encoder
Research Depth & Innovation
5/10
Depth of research and new ideas
Good engineering-level research translation: a self-correcting RAG state-machine (grade/verify/rewrite), measured ablations, and an experiment comparing LoRA tuning vs prompting.
Evidence
artirain-rag/rag/graph.py:build_graph (grade/rewrite/verify state machine)
finetune-vs-prompt/fvp/train.py:LoRA fine-tune experimental setup
Verified artifacts
Expertise
RAG• Senior
LLM• Senior
AI Agents & Agentic Workflows• Senior
MLOps & Model Lifecycle• Senior
Industries
Financial Services• Middle
Technologies
SQL
PostgreSQL
LangGraph
Rest API• since 2025
Claude• since 2025
ChatGPT
Qdrant• since 2025
Claude Code• since 2025
Helm• since 2025
GitHub Actions• since 2025
FastAPI
K3s• since 2025
Scikit-learn
FastEmbed• since 2025
GitLab CI• since 2025
PEFT
MS SQL
CI/CD
GitOps• since 2025
ArgoCD• since 2025
Transformers
Docker• since 2025
Kubernetes• since 2025
LLM• since 2025
RAG• since 2025
Asyncio• since 2025
HTTPX• since 2025
pre-commit• since 2025
Vector
Cloud• mentioned only
Fine-tuning• mentioned only
LoRA• mentioned only
Models• mentioned only
Recommendations
- Develop retrieval-augmented generation services and LLM orchestration (query rewriting, reranking, verify/grade loops).
- Implement fine-tuning and evaluation pipelines that compare PEFT/LoRA adapters vs prompting, with experiment tracking and reproducible metrics.
- Build small-to-medium LLM-backed automation agents that integrate browser automation (Playwright) and messaging (Telegram) for end-to-end workflows.
- Harden serving & MLOps: add monitoring, model versioning, secret management, and end-to-end CI for ingest/index/serve cycles.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium API Engineer
A practical mid-level backend engineer specializing in Python integrations and automation. The strongest proven skill is building reliable web-automation + LLM orchestration for application flows, evidenced by HHSource.apply, hunter/questions.py (LLM prompts and parsing) and hunter/llm.py test coverage. There is limited or no evidence of distributed systems design, advanced schema migrations, or production-grade observability and secret-management in the public code.
API Design
3/10
How well APIs are designed
Solid integration-focused API design for external services and LLMs (clear dry-run, error flows), but lacks advanced API versioning, idempotency keys, or formal error contract layers.
Evidence
hunter/apply.py: run (dry-run handling, CLI surface)
hunter/chat.py: decide_reply (LLM-driven reply decision and JSON parsing)
hunter/sources/hh.py: HHSource.apply (multiple response flows handled)
Data Layer & Database
2/10
Working with databases
Uses a simple SQLite-backed state with dedup and caching tested, but no migration history, explicit transaction boundaries, or tuned SQL/indices are present.
Evidence
hunter/state.py: make_fingerprint, State (sqlite3 usage, dedup and daily counters)
tests/test_state.py: tests for dedup, l1m cache and daily counter
Scalability & Performance
2/10
Handling load and speed
Practical single-process performance considerations (timeouts, HTTPX connection pool, sorted API results), but no queueing, caching-invalidation strategies, or measured optimization artifacts.
Evidence
avia-search-bot/bot.py: ApplicationBuilder HTTPXRequest (connection_pool_size and timeouts)
search_flights_text.py: search_flights (grouped vs exact fallback, limit handling and sorting)
System Architecture
3/10
Overall system structure
Clear modular decomposition (sources, llm, apply, questions, notify) and a documented pipeline design; architecture targets automation bots rather than distributed microservices.
Evidence
CLAUDE.md (job-hunter): pipeline design 'fetch → filter → classify → letter → apply → state + notify'
hunter/apply.py: orchestrates pipeline and composes components (Source, filter, classify, generate_letter)
Security & Auth
3/10
Protecting data and access
Credentials and session use are handled (dotenv, session export, Telethon usage) with some defensive checks; however there is limited evidence of hardened input validation, secret management, or token lifecycle controls.
Evidence
stufently/tdata-session-exporter/app/handler.py: export_bundle_from_tdata (writes .env and generates session files, uses set_key)
hunter/llm.py and tests/test_llm.py: code and tests for cleaning environment variables before calling LLM
Reliability & Observability
3/10
Stability and monitoring
Reliability patterns appear (retries around LLM parsing, timeouts/waits for Playwright actions, verification retries), but no full observability (structured logs/metrics/alerts) or advanced resilience frameworks.
Evidence
hunter/questions.py: answer_questions retry loop and fallback to incomplete
hunter/chat.py: decide_reply retries and _wait_chat_id timeout loop
hunter/sources/hh.py: _verify_applied retry logic after submit
Expertise
Backend AI & LLM• Middle
Python• Middle
Technologies
Python• since 2023 • Senior
Beautiful Soup• since 2025
SQLite• since 2025
Requests
python-telegram-bot
Recommendations
- Develop LLM-driven automation and integrations - work on pipelines that call LLMs, orchestrate browser automation and notify via messaging (Telegram).
- Build API connectors and scraping/automation components that require robust error handling and retries (e.g., Playwright integrations and form-filling flows).
- Implement tooling around session and credential management (secure session export, env handling) and add structured logging + metrics for reliability.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium UI Engineer
A frontend-focused developer at a solid junior-to-middle level who builds polished, small-to-medium client-side apps and prototypes. The strongest proven skill is crafting polished UI and UX (detailed CSS system and interactive client code - see the workout-tracker CSS and JS and the CRM index.css/store.ts integration). There is limited evidence of automated testing, large-scale system design, advanced server-state handling or formal accessibility tooling in public code.
UI Component Architecture
4/10
How interface parts are built
Modular, well-styled UI with deliberate CSS architecture and DOM-organized vanilla JS; lacks componentized framework-level boundaries or a custom React component library.
Evidence
Responsive & Cross-browser
6/10
Works on all screens and browsers
Responsive-first layouts, multiple breakpoints, safe-area handling and focused attention to reduced-motion and touch targets.
Evidence
Artirain/workout-tracker/css/app.css: media queries for mobile/tablet/desktop, safe-area-inset usage and many breakpoints
Artirain/lawyer-crm/src/index.css: responsive grid for stats and form adjustments
Artirain/workout-tracker/css/components.css: focus-visible, touch-target and reduced-motion rules
Performance Optimization
3/10
Speed of the interface
Some pragmatic run-time optimizations and lifecycle cleanup for charts and animation-aware patterns but no measured performance work or build-time optimizations.
Evidence
Artirain/workout-tracker/js/progress.js: destroyChart() to clean up Chart.js instances before re-creating
Artirain/workout-tracker/js/app.js: requestAnimationFrame used to drive toast visibility for smoother UI
Artirain/workout-tracker/js/data.js: localStorage caching and mergeWorkouts/mergeWater logic to limit duplicate processing
Accessibility & Semantics
3/10
Usable for everyone
Basic a11y-conscious CSS (focus-visible, reduced-motion) and some keyboard handling; lacks ARIA on custom widgets and no automated a11y tooling/config shown.
Evidence
Artirain/workout-tracker/css/components.css: .btn:focus-visible rules and explicit reduced-motion media queries
Artirain/workout-tracker/css/app.css: prefers-reduced-motion handling for animations
Artirain/workout-tracker/js/app.js: keyboard handlers for custom exercise input (Enter/Escape) to improve keyboard UX
State Management & Data Flow
4/10
Managing data in the app
Clear, pragmatic client-side state and server-fallback discipline (localStorage vs Supabase) and simple sync/merge flows; no advanced server-state caching, request cancellation, or optimistic rollback patterns.
Evidence
Artirain/lawyer-crm/src/lib/store.ts: usingSupabase feature flag and dual localStorage / Supabase CRUD implementations
Artirain/workout-tracker/js/data.js: WorkoutData.init() fetch/merge strategy and mergeWorkouts/mergeWater to reconcile remote JSON with localStorage
Artirain/workout-tracker/js/app.js: sessionExercises runtime state and saveWorkout flow
UX & Visual Polish
6/10
Look and feel quality
High visual polish - consistent token usage, micro-interactions, animations and thoughtful empty/error states create a professional UX for small apps.
Evidence
Artirain/workout-tracker/css/app.css: premium animations, toast positioning, water-ring animation and many micro-interaction rules
Artirain/workout-tracker/js/app.js: toast UX, last-workout comparison and save flow with immediate feedback
Artirain/lawyer-crm/src/index.css: polished dashboard tiles, badges and status styling
Expertise
HTML & CSS• Middle
Industries
Education• Middle
Lifestyle• Middle
Professional Services• Middle
Technologies
Node JS• Middle
Chart.js
React.js
Vite
Vercel• mentioned only
Recommendations
- Build and iterate small-to-medium single-page dashboards and admin tools where polished UI and client-side data handling matter (dashboards, CRMs, internal tools).
- Implement feature-focused prototypes and landing products that need strong visual design and responsive interactions (mobile-first static apps with client caching).
- Develop data-driven client apps with Chart.js and local/offline sync, improving sync edge cases and adding tests and CI/a11y checks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: