Arthur Damer
AI Engineer
SQL
Bash
PowerShell
Node JS
Python
Experimentation & Evaluation: 6/10
Model Architecture & Training: 5/10
Data Pipeline & Feature Engineering: 5/10
Active 23 days ago
+996 (557) 363671 Invite to interview
Message
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.
Technical skills
SQL
Bash
PowerShell
Node JS• Middle
Python• Senior • 3y+
Python
FastAPI
Requests
python-telegram-bot
Asyncio
Beautiful Soup
HTTPX
pre-commit
Databases
MS SQL
PostgreSQL
Qdrant
SQLite
AI/ML
ChatGPT
Transformers
PEFT
Scikit-learn
LangGraph
Claude
Claude Code
FastEmbed
LLM
RAG
Frontend
React.js
Chart.js
Vite
DevOps
CI/CD
Vector
ArgoCD
Docker
GitHub Actions
GitLab CI
GitOps
Helm
K3s
Kubernetes
Rest API
QA
Pytest
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
Claude
ChatGPT
Qdrant
Claude Code
Helm
GitHub Actions
FastAPI
K3s
Scikit-learn
FastEmbed
GitLab CI
PEFT
MS SQL
CI/CD
GitOps
ArgoCD
Transformers
Docker
Kubernetes
LLM
RAG
Asyncio
HTTPX
pre-commit
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• Senior • 3y+
Beautiful Soup
SQLite
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: