Technical Lead

LILA; Bengaluru; On-site; INR 3,500,000 - 5,500,000; Full time

Job summary

Lila Games, based in Bangalore, India, is seeking a Tech Lead to ship new games rapidly while building shared systems and tooling. You will work across backend and frontend, using Unity, Godot, or other engines, and remain comfortable with multiple tech stacks.

You will mentor the engineering team in Bangalore, ensure testable, configurable liveops, and own features end to end across projects from scoping to shipped releases. This is a hands-on role.

Qualifications

• Deep understanding of SOLID principles and live-ops safety.
• Proficient across backend and frontend; quick to learn stacks.
• Hands-on coding with AI agents and guardrails.
• Experience building liveops features with configurable pipelines.
• Strong mentorship and feedback skills.
• High ownership and proactive problem solving.

Responsibilities

• Build shared foundations and systems for multiple games.
• Design liveops capable features and dashboards/configs.
• Lead end-to-end features across backend/frontend.
• Mentor Bengaluru engineering team through code reviews and hands-on guidance.

Skills

Strong engineering fundamentals

Full-stack across backend and frontend

Hands-on agentic coding

Liveops systems thinking

Mentorship and feedback

High agency

Unity proficiency bonus

Tools

Unity

Job description

Lila Games strives to build a world-class engineering team (eventually) that can compete with the best in the world. We are a long way from that ambition, but we hope to find others to help us build this team from Bangalore, India. Built in India, published to the world.

More information about Lila: https://tr.ee/7DD-CnUfci

Why This Role Exists:

We are a multi-game studio, and our biggest constraint is how fast we can ship new games. We need a Tech Lead who helps us ship new games faster, both by working directly on the games and by building the shared systems and tooling that multiple projects reuse.

This is a full-stack, full-lifecycle role. The work spans backend and frontend, in Unity, Godot, or whatever a project uses. You should be comfortable picking up new tech stacks fast. You will not be boxed into one engine or one game.

What You Will Own:

• Build shared foundations and systems: Design the systems and tooling that multiple projects reuse, so new games start from a stronger base instead of rebuilding the same things each time.
• Build for liveops operability from day one: Every feature you ship should be operable without engineering involvement after launch. Designers should be able to adjust weapon balance, drop rates, event timing, and economy levers through config or dashboards, not by filing engineering tickets. Think about who operates what you build, not just whether it works on launch day.
• Design scalable features: Architect features that hold up as a game grows in players and content, and that work across projects rather than being rebuilt each time.
• Build testable systems, not just tested systems: Pure logic (economy calculations, matchmaking, config parsing, anything that does not touch the engine) should be unit tested. Gameplay systems should be designed so their logic can be validated without running the full game. You do not need TDD dogma everywhere, but you must know what to test, what not to test, and how to architect so testing is possible.
• Own features end to end across projects: Take features from scoping to shipped, across backend and frontend, often on more than one game at a time. Translate requirements into well-scoped engineering tasks with realistic estimates, in collaboration with product and design.
• Lead and mentor the engineering team in Bangalore: Most engineers have not received structured technical feedback. Code review is your primary mentorship tool: specific, technical, and instructive. Your goal is to raise the floor of every engineer around you.

Working With AI:

You should be comfortable building with AI agents as part of your normal workflow:

• Agentic coding: using AI agents to write and ship code day to day.
• Agentic loops with guardrails: setting up workflows where agents do real work within constraints and checks you define.
• Self-healing agent loops: workflows that detect their own failures and correct themselves.

What We Are Looking For:

We care more about depth of skill and quality of thinking than years of experience. Here is what actually matters:

• Strong engineering fundamentals: you understand SOLID principles and can explain why they matter in the context of a game codebase, specifically why they make live-ops changes safer and faster, not just cleaner.
• Full-stack and quick with new stacks: you are comfortable across backend and frontend (Unity, React, or whatever a project uses) and you pick up unfamiliar tech stacks fast.
• Hands-on agentic coder: you write code day to day and use AI agents to do it. You are comfortable with agentic loops and the guardrails that keep them reliable. This is not a management-from-a-distance role.
• Liveops systems thinking: you have worked on a live game and understand what it means to build features that can be tuned, toggled, or updated without a full build. You think about config, feature flags, and content pipelines as engineering concerns, not product team problems.
• Mentorship instinct: you give direct, specific technical feedback. You can explain not just what is wrong but why and how to fix it.
• High agency: you identify problems and propose solutions without waiting to be asked. You own outcomes, not tasks.

Unity proficiency is a bonus. Backend or networking experience is valuable given the multiplayer games that we work on.

What We Are Not Looking For:

• Engineers who equate years of experience with expertise. We have seen too many senior engineers with bad habits and too many sharp 4-year engineers who outperform them.
• People who profile only when performance is already broken. By then it is too late.
• Engineers who build features without thinking about who operates them post-launch. Liveops operability is an engineering responsibility.
• People who prefer to manage from a distance. We need someone in the code.