Senior Technical Lead-Full-Stack AI Engineer.

Pangloss Reimbursement Management; India; Remote; INR 3,000,000 - 5,000,000; Full time

Job summary

Pangloss Reimbursement Management is seeking an experienced Senior Technical Lead to own the full technical lifecycle of product development. You will bridge client/product needs with engineering, translate requirements, design architecture, estimate effort, and guide a team of engineers across AI, full-stack, and QA.

You will remain hands-on, review and improve production code, and lead technical audits to ensure scalable, secure, and reliable solutions aligned with long-term product goals.

Qualifications

• Bachelor's in Computer Science or equivalent.
• Experience leading technical teams and end-to-end delivery.
• Strong architecture and design skills for backend, frontend, AI, and data flows.
• Proven ability to translate business requirements into technical plans.

Responsibilities

• Own the technical lifecycle from requirements to production release.
• Lead architecture design for major features and product changes.
• Plan, scope, estimate, and sequence development work.
• Mentor engineers and ensure quality across code, tests, and deployments.
• Coordinate with QA/DevOps for production readiness and release.

Skills

Technical leadership

Architecture design

Backend & frontend

AI integration

Team mentoring

Client & product alignment

Education

Bachelor's in Computer Science

Tools

OpenAI API

LangChain

Pinecone

Weaviate

Milvus

Job description

Position Overview

We are looking for an experienced Senior Technical Lead to take end-to-end technical ownership of product development and feature delivery.

This role sits between the client/product team and the engineering team. You will participate in client and stakeholder discussions, understand new product requirements and improvements, translate them into technical solutions, design the architecture, scope and estimate the implementation, guide developers through execution, audit development quality, and ensure successful production release.

You will lead a team of approximately 6 engineers across AI, full-stack development, and QA.

This is not purely a people-management role and not simply a senior developer position. We are looking for someone who can own the complete technical lifecycle:

Requirement Solution Design Architecture Scope Estimate Development Plan Implementation Oversight Code Review QA Release Production Validation

While developers will execute much of the implementation, the Technical Lead remains accountable for ensuring the work is properly planned, technically correct, delivered on time, and productionready.

You should remain technically hands-on and capable of reviewing, debugging, improving, and where necessary contributing to production code

------------------------------------------------------------------------------------------------------------------

Key Responsibilities

1. Client & Product Requirement Ownership

Work directly with clients, product stakeholders, and leadership to understand:

• New product features
• Product improvements
• Workflow changes
• AI capabilities
• Integrations
• Performance requirements
• Technical issues
• Architecture changes

You will be expected to:

• Understand both the business requirement and its technical implications.
• Ask the right questions before development begins.
• Identify missing requirements, dependencies, edge cases, and risks.
• Challenge unclear or technically unsuitable approaches.
• Translate requirements into clear technical implementation plans.
• Explain technical options and trade-offs to both technical and non-technical stakeholders.

2. Architecture & Technical Solution Design

Own the technical design of significant features and product changes.

Responsibilities include:

• Review existing architecture before proposing changes.
• Design backend, frontend, database, AI, API, and integration architecture.
• Define system and data flows.
• Identify dependencies across existing components.
• Select appropriate technologies and implementation patterns.
• Consider scalability, security, performance, reliability, and maintainability.
• Create technical specifications and architecture diagrams where required.
• Ensure new development remains aligned with the long-term architecture of the product.
• The Technical Lead should be able to simplify solutions where possible while recognising when stronger architecture is required.

3. Technical Scoping, Estimation & Planning

Before development starts, convert product requirements into an actionable engineering plan

This includes:

• Break requirements into technical components and development tasks.
• Define frontend, backend, database, API, AI, integration, infrastructure, and QA requirements.
• Identify technical dependencies and risks.
• Define technical assumptions and edge cases.
• Estimate development effort and timelines.
• Determine required skills and developer allocation.
• Establish the implementation sequence.
• Define acceptance and technical completion criteria.

Significant development should not begin without sufficient technical planning.

The Technical Lead is responsible for ensuring estimates are realistic and that potential delays or technical risks are identified early.

4. Development Leadership & Technical Audit

Guide the engineering team throughout implementation.

Responsibilities include:

• Explain architecture and implementation approach to developers.
• Assign work based on developer capability.
• Resolve technical questions and blockers.
• Monitor development progress against scope and timeline.
• Ensure developers follow the agreed architecture.
• Identify scope drift and architectural deviations early.
• Review critical implementation decisions during development.
• Mentor engineers and improve technical capability across the team.

The Technical Lead is also responsible for auditing development quality, including:

• Code architecture and structure
• API implementation
• Database implementation
• AI integration
• SecurityError handling
• Performance and scalability
• Logging and monitoring
• Maintainability and reusability
• Test coverage
• Technical debt

Code review in this role is not simply approving pull requests. You must determine whether the implementation itself is technically correct and appropriate.

5. Quality, Release & Production Ownership

Work closely with QA and DevOps to ensure every significant release is production-ready.

Responsibilities include:

• Define important technical test scenarios and edge cases.
• Review unit, integration, API, E2E, and AI workflow testing.
• Evaluate regression risks.
• Verify integration dependencies.
• Review release readiness.
• Review database migrations and configuration changes.
• Identify deployment dependencies and rollback requirements.
• Coordinate production deployment.
• Validate critical functionality after release.
• Monitor post-release behavior.
• Lead technical investigation of significant production issues.

The Technical Lead remains accountable until the feature has been successfully validated in production

Our products increasingly use AI as a core part of the product architecture. The Technical Lead should

have hands-on experience delivering AI functionality in production.

Experience should include production use of one or more of:

• OpenAI
• Anthropic
• Google Vertex AI
• Hugging Face

Knowledge should include:

• LLM API integration
• Prompt and system-prompt engineering
• Few-shot prompting
• Structured outputs
• Function/tool calling
• RAG architecture
• Embeddings and retrieval
• Agentic workflows
• Multimodal AI
• Document and PDF processing
• Image/vision processing
• AI output validation
• API failure handling
• Rate limiting and retries
• Token and context optimization
• Caching strategies
• AI latency and cost optimization
• AI security and prompt-injection considerations

Experience with the following is strongly valued:

• LangChain
• LangGraph
• Pinecone
• Weaviate
• Milvus or similar vector databases

Candidates should have worked with AI APIs in a real shipped product, not only personal experiments or prototypes. The existing role also expects familiarity with RAG and production LLM frameworks.