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
