AI / LLM Engineer: market

Vacancy

an open job that cleared the quality gate and lists at least two technologies

Observed candidate

a candidate whose stack contains this technology; an aggregate — not a single record leaves the perimeter

Matchable candidate

not counted yet

Window

jobs open at the moment the snapshot was built

Junior — typical entry: Backend Middle / ML Engineer Middle / Data Scientist Middle + LLM hobby projects (demonstrable RAG + LangChain experience). The Junior → Middle jump — after the first production LLM-feature deployment (chatbot / summarisation / Q&A in a real product with real users). Middle → Senior — multi-feature LLM ownership + cost optimisation (typical mandate: 50-70% reduction in LLM API costs through caching + smaller models + RAG vs fine-tuning trade-offs) + evaluation methodology. Senior → Staff / Principal — org-wide AI strategy + multi-product LLM platform architecture. Career flow: Backend Senior / ML Engineer Middle (2-3 years) + LLM interest → AI Engineer Junior / Middle (1-2 years) → Senior → either Staff / Principal AI Engineer, AI Tech Lead / Engineering Manager, a move into a frontier-AI lab, or AI startup founder.

Top 5: python, cloud, aws, llm, agile. Python deep (monopoly — async / typing / FastAPI). Each provider has its quirks (rate limits + retry strategies + cost per token + feature support). LLM Frameworks: LangChain mastery — the largest job market (LCEL — LangChain Expression Language, callbacks, agents, retrievers), LlamaIndex (RAG-focused — data ingestion + indexing strategies), Haystack (deepset), Semantic Kernel (Microsoft for.NET shops), LangGraph (DAG-style agent orchestration — LangChain), AutoGen + CrewAI (multi-agent — rising), DSPy (Stanford — declarative LLM programming, growing). Vector DB mastery: Pinecone (managed leader), Weaviate (open-source modular), Qdrant (Rust-based — fast self-hosted), Milvus (enterprise scale), Chroma (lightweight dev / prototyping), pgvector (Postgres extension — production-friendly for existing Postgres shops), Elasticsearch dense_vector + Redis Stack (hybrid full-text + vector). Fine-tuning: LoRA + QLoRA via PEFT library (Hugging Face — standard 2026), Unsloth (faster LoRA training), Axolotl (config-driven fine-tuning). Full fine-tuning rare (cost prohibitive). RLHF / DPO / KTO: TRL library (Hugging Face — Direct Preference Optimization growth 2024+). Evaluation: RAGAS (RAG-specific — faithfulness + answer relevancy + context precision), DeepEval, lm-evaluation-harness (academic benchmarks), Inspect AI (UK AISI safety-focused), Promptfoo (regression testing for prompts), LangSmith (LangChain trace + eval — best UX). Observability + tracing: Helicone (LLM-specific APM), LangSmith, Langfuse (open-source), Arize Phoenix, Datadog LLM Observability (2024+ feature). Cost optimisation: prompt caching, prompt compression (LLMLingua), model routing (small model for easy queries, large for complex — through providers like Martian / OpenRouter).

Data Scientist — focus on statistical modelling + A/B testing + business problem framing. Stack: pandas + sklearn + XGBoost + Jupyter + SQL + Tableau. See Data Scientist. ML Engineer — focus on production ML pipelines + deployment + scaling. Stack: PyTorch + sklearn + Kubernetes + MLflow + cloud-managed ML. Generalist — works with recsys / fraud / ranking / classical ML. See ML Engineer. AI Engineer (this page) — focus on LLM integration in product. Does NOT train foundation models (that's Research), does NOT build classical ML pipelines (that's ML Engineer). Stack: Python + LLM providers + LangChain / LlamaIndex + vector DBs + vLLM serving + RAG patterns + LoRA fine-tuning + LLM evaluation tools. Key distinction 2026: AI Engineer reuses pre-trained LLMs, ML Engineer often trains models from scratch. AI Engineer works with API/prompts/RAG; ML Engineer — with training loops + feature engineering. Career pivots: Backend Senior → AI Engineer Junior — 2-4 months (fast ramp thanks to API-based work + learnable LangChain). ML Engineer Senior → AI Engineer Senior — 1-3 months (already knows stack basics, needs to deepen LLM-specific). DS Senior → AI Engineer Middle — 3-6 months. AI Engineer Senior → Research — requires deeper math + paper-writing experience + 6-12 months of preparation.

Decision tree for LLM customisation 2026: 1) Prompt Engineering — first try. Use case: zero-shot or few-shot ENOUGH for the task. Pros: zero cost (no training), instant iteration, model-agnostic. Cons: limited control, prompt fragility, context-window pressure. 2) RAG (Retrieval-Augmented Generation) — best for knowledge-grounded tasks. Use case: chatbot, Q&A, document search, customer support, code documentation, internal knowledge bases. Architecture: query → embed → vector search → top-k documents → augment prompt with retrieved context → LLM generates answer. Pros: factual grounding (anti-hallucination), up-to-date (just update the index, no retraining), source citation possible, cheaper than fine-tuning. Cons: retrieval quality bottleneck, prompt size grows. RAG stack 2026: ingestion (LlamaIndex / LangChain document loaders) → chunking strategy (semantic vs fixed-size vs recursive) → embeddings → vector DB (Pinecone / Qdrant / Weaviate / pgvector) → retrieval (similarity + reranking via Cohere Rerank / BGE Reranker) → prompt augmentation → LLM generation. Advanced RAG: hybrid search (vector + BM25), HyDE (Hypothetical Document Embeddings), query rewriting, multi-hop retrieval, self-reflection (CRAG / Self-RAG). 3) Fine-tuning — use when prompt engineering + RAG aren't enough. Use case: a) domain-specific style / format (medical / legal — specific phrasing patterns), b) reduce token cost (a smaller fine-tuned model replaces a larger general model), c) tasks requiring deep specialised knowledge (where RAG context window doesn't help). Modern fine-tuning: LoRA / QLoRA (PEFT) — train small adapter (~1% of weights), full fine-tuning rare. Stack: Hugging Face Transformers + PEFT + TRL + Unsloth (faster) + Axolotl (config-driven). Hardware: 24GB GPU (RTX 4090 / A6000) for 7-13B models, 80GB+ (A100/H100) for 70B+. Cost reality 2026: prompt engineering — minutes, $0. RAG setup — 1-2 weeks engineering, $100-1,000/mo API costs. 4) Combination: real production AI features typically use ALL three. Prompt engineering first (system prompts + few-shot examples) → RAG for grounding → optional LoRA fine-tuning for style/format. 5) Agentic patterns (rising 2025–2026) — LLM + tool use + multi-step reasoning. Use LangGraph / AutoGen / CrewAI / DSPy. Default 2026: RAG for 80% of production use cases + prompt engineering for prototyping + LoRA fine-tuning only if RAG is explicitly insufficient + agents for complex multi-step workflows.

Yes, 31% of AI Engineer jobs are full-remote or hybrid. AI Engineer work is fully cloud-based (LLM APIs + vector DBs + cloud GPUs — all remote-accessible). Outsourcers (EPAM AI / Luxoft AI / Andersen AI / DataArt AI) — almost always remote on US AI projects. Russian banks — hybrid/office due to AI-data compliance. International frontier-AI labs — full-remote standard for exceptional candidates. Big Tech AI — hybrid standard. Y Combinator AI startups — premium full-remote. English for international AI remote — must (premium +40-60%, and the AI community / papers / docs are entirely English).

Roadmap: 1) Python deep + Backend basics — async / typing / FastAPI / pytest. Without Backend skill — not an AI Engineer (just a prompt jockey). Book: "Fluent Python" Ramalho. 2) LLM fundamentals understanding — transformer architecture basics (attention + tokenisation + decoding strategies + context windows), but you don't need to implement from scratch. Course: "Building LLMs from scratch" Karpathy YouTube (free — best for intuition). Book: "Hands-On Large Language Models" Jay Alammar / Maarten Grootendorst (2024 — must-read). 3) OpenAI API mastery — chat completions + function calling + structured outputs + streaming + assistants. Build a minimum of 3 real apps. Free credits + cheap experimentation. 4) Anthropic Claude API mastery — best for coding + long-context use cases. Tool use + prompt caching + computer use (if AI Agent track interests you). 5) LangChain mastery — the largest job-market requirement. LCEL (LangChain Expression Language), chains, agents, retrievers, callbacks. Course: "LangChain & Vector Databases in Production" DeepLearning.AI (free). 6) RAG architecture deep — document loaders + chunking strategies (semantic / fixed / recursive) + embeddings choice + vector DB selection + retrieval algorithms + reranking. Build a production RAG app with advanced patterns (hybrid search + reranking + HyDE). 7) Vector DB mastery — at least one deeply (Qdrant — best for self-hosted learning) + one managed (Pinecone). Understanding HNSW / IVF / PQ algorithm basics. 8) Fine-tuning hands-on — LoRA / QLoRA via PEFT library + Unsloth (faster). Fine-tune Llama 3.x 8B on your own dataset. Hardware: Google Colab Pro+ ($50/mo) or RunPod / Vast.ai (cheap GPU rental). 9) vLLM serving — deploy an open model with vLLM + benchmark throughput + compare with OpenAI API. 10) Evaluation mastery — RAGAS + DeepEval + custom evaluation suite. Build a regression test for prompts. 11) LangSmith / Langfuse observability — instrument a production app + analyse traces + identify bottlenecks. 12) Agent frameworks — LangGraph + AutoGen + CrewAI + DSPy basics. Build a multi-agent demo (research agent + writing agent + critic agent). 13) Pet-project portfolio: production-grade AI feature (e.g. document Q&A for an open dataset) with RAG + evaluation + observability + cost tracking. Document as portfolio (GitHub + blog post + demo video). RU courses: Karpov.Courses "AI Engineer" track, Otus "LLM Engineering", HSE School of AI, School21 (Sber) AI Engineer track. Must-read books: "AI Engineering" Chip Huyen (2024), "Hands-On Large Language Models" Alammar / Grootendorst, "Building LLMs for Production" Bouchard / Peng. Backend Senior + LLM interest → AI Engineer Junior — 2-4 months (fastest entry into the ML world). ML Engineer Senior → AI Engineer Senior — 1-3 months. Data Scientist → AI Engineer Middle — 3-6 months.

61 active open AI Engineer positions in our sample — a young niche (split off in 2023 after the ChatGPT boom). The real market is much broader — most AI Engineer roles are classified by our matcher as general ML Engineer or Backend (because titles are often "Senior Backend Engineer (AI focus)" or "ML Engineer — LLM"). The true pool of AI-focused dev jobs across CIS + Europe is estimated at 500-2,000 active positions at any moment in 2026 (accounting for fuzzy-classified ones). Geography: Russia / Poland / remote. Time to close a Senior AI Engineer role — 4-10 weeks in Russia, 6-12 weeks international (rare-skill premium). Trend 2026: the AI Engineer pool grows fastest among all IT categories — we see 3-5× year-over-year growth in LLM-mentioning job postings.

A Senior AI Engineer owns the full LLM-product engineering cycle + cost optimisation + technical leadership. Python deep + Backend Senior level: async / typing / FastAPI / pytest mastery. Open LLM knowledge: Llama 3.x / Mistral / Qwen 2.5 / DeepSeek V3 + R1 / Phi 3 / Gemma 2 — performance / cost trade-offs, when to use which. LangChain mastery: LCEL deep, callbacks, agents, retrievers, custom chain authoring, debugging through LangSmith. Or equivalent in LlamaIndex / Haystack / Semantic Kernel. RAG architecture mastery: advanced patterns (hybrid search BM25 + vector, reranking, HyDE, query rewriting, multi-hop retrieval, self-reflection patterns CRAG / Self-RAG), chunking strategies (semantic + recursive + hierarchical), embedding model selection. Vector DB mastery deep: one of Pinecone / Qdrant / Weaviate / Milvus / pgvector deeply — index tuning, sharding, replication, hybrid search implementation. Fine-tuning mastery: LoRA / QLoRA via PEFT + Unsloth + Axolotl, dataset preparation (instruction tuning + DPO data), hyperparameter selection, evaluation methodology. RLHF / DPO / KTO basics: TRL library for preference optimisation. Serving mastery: vLLM advanced (PagedAttention + continuous batching + speculative decoding + KV cache optimisation), TGI, SGLang. Agent architectures: LangGraph + AutoGen + CrewAI + DSPy mastery, MCP (Model Context Protocol) implementation, tool use design patterns, multi-agent orchestration. Evaluation mastery: RAGAS + DeepEval + custom evaluation suite design, LLM-as-judge methodology, regression testing for prompts, A/B testing for LLM features. Observability + tracing: LangSmith + Langfuse + Helicone + Arize Phoenix + Datadog LLM Observability mastery. Cost optimisation mastery: prompt caching strategies (native + custom Redis), prompt compression (LLMLingua), model routing (small for easy / large for complex via OpenRouter / Martian), batch API for non-real-time. Typical Senior mandate: 50-70% reduction in LLM API costs. Safety / guardrails: NeMo Guardrails, Llama Guard, OpenAI Moderation API integration, prompt injection defence, output filtering. System design for LLM products: design a RAG-based product on whiteboard at 100M+ queries/day scale, multi-region considerations, latency budgets (target P95 < 2s for chat). Soft: ADRs writing for LLM architecture decisions, technical writing (LLM feature design docs), cross-team collaboration (Product / Backend / DS / Research teams), mentoring Middle AI Engineers, paper-reading discipline (NeurIPS / ICLR / EMNLP — must follow). English for Senior+ MUST — AI community / docs / papers / conferences are entirely English. Optional bonus: open-source contributions to LangChain / LlamaIndex / vLLM / Hugging Face — sharply increase market value for frontier-AI labs hiring. Twitter AI presence (regular posting about LLM experiments) — important for hiring through community connections.