About the Company

Growtrics is an AI EdTech company building the infrastructure layer for personalized learning at scale. Our core products span AI-generated educational video, adaptive learning paths, automatic grading and feedback, and agentic workflows that coordinate across LLMs, content systems, and human reviewers.

We are a small, high-output team. The work is technically ambitious and the pace is fast.

About the Role

We're not hiring a backend engineer who uses AI tools. We're hiring someone who thinks in LLM architectures first.

You'll take a vague product or ops problem, scope it yourself, choose the architecture, build it end to end, and own the outcome — no spec, no architect above you.

You should understand how LLMs fail, how to build reliable systems around non-deterministic inference, how to evaluate AI output at scale, and how to wire that into production backends that hold up.

If you think in agents, pipelines, eval loops, and structured outputs before you think in endpoints and tables — this is your role.

What You Will Work On

You will own significant slices of Growtrics backend and AI infrastructure across two products and our internal engineering platform.

Growtrics — AI-Powered Mobile Education

Growtrics delivers byte-sized, high-value educational content to learners at very low cost. The engineering challenge is not just generating content — it is generating it reliably at scale. We are talking about millions of questions and learning assets produced for tens of dollars, not thousands.

That requires serious multi-agent architecture: generation pipelines that degrade gracefully, evaluate their own output, retry on failure, and route to human review only when genuinely needed. You will work on:

Content generation pipelines — multi-agent systems that produce questions, explanations, and learning sequences at scale, with structured output contracts and LLM as-judge quality gates
Cost and reliability architecture — designing generation systems where cost-per output is a first-class engineering metric, and reliability is achieved through smart fallback and evaluation, not just redundancy
AI-generated video — multi-stage agentic pipelines that plan, script, render, audit, and revise short-form educational video using LLMs and code generation
Learning path intelligence — pipelines that reason over learner behavior and content metadata to make real-time personalization decisions

TaloTrace — Agentic QA at Scale

TaloTrace is Growtrics internal system for assuring software quality through agent-driven simulation. The goal is to replace slow, manual QA cycles with agents that simulate real user behavior across full application flows — catching regressions, edge cases, and integration failures before they reach production.

You will work on:

Behavioral simulation agents — LLM-backed agents that simulate real user journeys end to end across mobile and web flows, at a scale no human QA team could match
Automated regression and anomaly detection — pipelines that run after every deploy, compare against expected behavior, and surface failures with enough context to act on immediately
Agent-driven test generation — systems that use LLMs to generate, validate, and maintain test coverage as the product evolves, without manual upkeep

Engineering Velocity Platform

We believe how engineers work should itself be engineered. We're offloading the grunt work — linting, standards enforcement, requirement checking, code review, QA, and as much routine implementation as possible — onto agents, so engineers can focus on creative and architectural work.

This means:

Agentic coding harness workflows — designing systems and standards around Claude Code, Codex, and Cursor so that agents can drive implementation end to end, not just assist at the margins
Automated code standards and review — agents that enforce conventions, catch regressions, and flag quality issues as part of the normal development loop, not as a manual gate
Requirements and spec checking — pipelines that take loosely stated product requirements and translate them into structured, testable contracts before a line of code is written

The philosophy here is: if an agent can do it, the agent should do it. Your job is to design the systems that make that reliable

You will scope these projects yourself, propose the architecture, make the tradeoffs, build it, and operate it. You will not be handed a spec.

What We Expect

End-to-End Ownership

You take problems from first principles to production—asking the right questions early, identifying real constraints, and delivering systems that work, not just demo. You don't need a PM to keep you moving or an architect to validate your decisions.

AI-Native Thinking

You design systems where LLMs are a core structural component, not a feature sprinkled on top. You know how to:

choose the right model for the job and justify the cost-latency-quality tradeoff
write prompts that behave reliably at scale, not just in a test notebook
structure outputs with schemas, contracts, and validation so downstream systems can depend on them
build evaluation and audit loops that catch LLM failures before they reach users
know when an agent should hand off, retry, ask a human, or fail closed

You treat LLM nondeterminism as a first-class engineering constraint, not a footnote.

Strong Backend Foundations

You have deep, practical experience building backend systems: async job execution, durable queues, state machines, idempotency, retries, observability. You know why BackgroundTasks is not a job queue. You know when to reach for Pub/Sub vs Cloud Tasks vs Redis. You can design a system that recovers gracefully from partial failure.

Independent Operation

You work best when given a problem and trusted to figure it out. You raise blockers early and communicate clearly. You do not disappear into long implementation cycles without surfacing tradeoffs or asking for course-correction input when needed.

Technical Skills

4–10 years of hands-on backend engineering experience, with at least 2 years building agentic or LLM-backed systems in production or production-like environments
Deep proficiency in Python — async, type-safe, well-tested code
Hands-on experience building multi-agent and agentic LLM pipelines: tool use, structured output, evaluation loops, retry/repair, human-in-the-loop
Experience with multiple LLM providers — OpenAI, Anthropic Claude, Google Gemini — including understanding of their distinct failure modes, pricing, context limits, and structured output capabilities
Practical experience with agent orchestration frameworks such as LangGraph, LangChain, CrewAI, or equivalent — or the judgment to know when not to use them
Experience designing LLM-backed job pipelines: multi-stage generation, validation, fallback, and audit
Strong experience building APIs and services with FastAPI
Experience with cloud-native async infrastructure: Cloud Tasks, Pub/Sub, Cloud Run, or equivalent on GCP/AWS
Ability to scope and architect systems independently — identify requirements, propose design, make explicit tradeoffs
Strong instincts for LLM reliability: prompt contracts, schema enforcement, retry policies, evaluation harnesses, and graceful degradation

Strong Advantage

Experience with agentic coding harnesses (Claude Code, Codex, Cursor) as a daily implementation tool — not just for autocomplete, but for driving real system design and implementation
Experience building LLM evaluation frameworks: judge panels, rubric-based scoring, structured output auditing
Experience with Firestore, Firebase, GCP (Cloud Run, Cloud Storage, Cloud Tasks, Pub/Sub)
Experience with vector databases (Qdrant, Weaviate, Milvus) and retrieval-augmented generation
Experience with code generation pipelines: LLM-generated code, AST validation, sandboxed execution
Experience designing for cost observability — tracking token spend, model selection tradeoffs, and cost-per-output at pipeline level
Familiarity with DevOps, CI/CD, and observability for AI systems (structured logging, latency tracking, failure alerting)

What We Are Not Primarily Looking For

We are not looking for engineers who are strong at backend fundamentals alone and are now learning AI. We have junior engineers who are still building that foundation.

For this role, AI-native reasoning is the baseline. Backend depth is the complement.

Soft Skills

Systems thinker — sees the problem behind the problem, designs for failure modes, not just the happy path
Clear communicator — explains complex architecture in two paragraphs, flags risk in one sentence
High autonomy, low drama — runs independently, surfaces blockers early, no chasing needed
Strong written English for async work; clear, concise verbal communication for calls
Decisive under uncertainty — commits to reasonable architecture choices with incomplete information

Years of Experience

We are looking for candidates with 4–10 years of total engineering experience, with a meaningful portion of that in agentic or LLM-backed systems.

The 4-year floor is firm: we need someone who has seen enough production failure modes to build systems that hold up.

The 10-year ceiling is a guide, not a cutoff. We care about the quality of what you have built, not the number of years on a resume.

Why Join Growtrics

Competitive compensation package, including 100% salary during probation
13th-month salary & performance bonuses
Full social insurance on gross salary
Premium health care
14 annual leave days + 6 sick days
Flexible working hours
MacBook provided
No strict dress code (comfortable but professional)
Full compliance with the Vietnam Labor Code
Employee well-being perks (gym membership, social events, Thursday drinks, fruit served twice a week)
Opportunity to work with global stakeholders
Dynamic, international, and creative work environment
Pantry stocked with snacks & beverages
Recognition based on skills and performance
Strong learning & career development opportunities

Senior Agentic Backend Engineer