Tech ProgramManager Role

Tech Manager Intro

===

I’m Anand Nerurkar, currently working as a Senior Application Development Manager with over 21 years of IT experience across software development, technology solutioning, and technical delivery leadership.

For the past decade, I’ve operated in a 60:40 technical-to-delivery ratio, providing hands-on technical leadership in Java 17, Spring Boot microservices, Kubernetes, Kafka, Docker, OCR, RDBMS, Angular, and multi-cloud adoption across Azure, AWS, and GCP.

I take full ownership for end-to-end delivery, engineering excellence, and overall team growth. I’ve led cross-functional global engineering teams and driven enterprise-grade transformation programs across digital modernization, cloud migration, cybersecurity, DevOps, and DevSecOps — delivering tangible outcomes like:

• 30% cost savings

• 45% reduction in downtime

• 40% fewer security incidents

• And improved security posture using Zero Trust frameworks.

Currently, I manage delivery across three major tracks — digital lending, mutual fund platform modernization, and payment automation — each with 6–7 engineers. I oversee solution design, development, testing, and production deployment, while driving agile ceremonies and ensuring alignment across stakeholders, risks, and delivery goals.

On the people side, I actively support career development, performance cycles, conflict resolution, and team mentoring, creating a culture of trust and continuous improvement.

In short, I bring a strong blend of technical depth, delivery discipline, and people-first leadership. I’m excited about this role, as it aligns closely with my strengths — and I look forward to contributing as a Tech Manager on your team.

Thank you.

=======

Mock Interview Questions & Structured Answers: Tech Delivery Manager Role

❓ Q1: Tell me about a program you've led involving multiple agile squads.

Structured Answer (STAR Format):

• Situation: I led a modernization program for a Mutual Fund Platform involving 4 agile squads.

• Task: The goal was to re-architect the legacy system using microservices on Azure cloud.

• Action:

  • Defined the product roadmap with the business team and architects

  • Facilitated PI planning and synchronized 2-week sprints across squads

  • Set up Scrum of Scrums, JIRA dashboards, and shared Definition of Done

  • Managed risks and dependencies across squads via a centralized RAID log

• Result: Delivered 90% of the committed features within 3 program increments, improved investor onboarding by 60%, and reduced production incidents by 40%.

❓ Q2: How do you handle cross-squad dependencies and delivery risk?

Structured Response:

• Maintain a program-level dependency tracker in Confluence/JIRA

• Use Scrum of Scrums twice a week to surface and resolve blockers

• Pre-emptively engage Architects/POs for shared APIs or services

• Use contract testing (Pact) to decouple releases

• Apply risk mitigation strategies (parallel mocks, feature flagging)

Result Example: Avoided a 2-week delay due to RTA API dependency by introducing a mock API and parallel integration testing.

❓ Q3: How do you ensure delivery quality across multiple agile teams?

Structured Answer:

• Standardized Definition of Done across all squads

• Mandatory code reviews, unit/integration tests, and SonarQube scans

• Shared CI/CD pipeline using Azure DevOps

• Quarterly cross-squad retrospectives to align best practices

• Regular monitoring with Prometheus, Grafana, Azure Monitor

Impact: Improved sprint predictability and ensured 95%+ deployment success rate.

❓ Q4: Tell us about a time you managed a major incident or escalation.

STAR Response:

• Situation: During UAT for a mutual fund SIP flow, a bug caused incorrect investor allocations.

• Task: Fix the issue and restore stakeholder confidence before go-live.

• Action:

  • Triggered a WAR room with QA, Dev, and Product

  • Performed root cause analysis (config mismatch + data validation gap)

  • Rolled out a hotfix with extended QA regression

  • Conducted RCA doc review with leadership and implemented controls

• Result: Resolved within 48 hours, preserved go-live schedule, improved UAT feedback scores.

❓ Q5: How do you ensure business alignment and stakeholder satisfaction?

Response:

• Regular demo sessions with business owners and distribution partners

• Created OKRs/KPIs aligned to business outcomes (e.g., onboarding speed, AUM growth)

• Weekly reporting on delivery health (velocity, risks, blockers)

• Collected stakeholder feedback every sprint and adjusted priorities

Impact: Maintained >90% stakeholder satisfaction in CSAT surveys during the program.

❓ Q6: How do you balance tech debt vs. feature delivery?

Response:

• Educate product owners on long-term tech health

• Allocate 15–20% sprint capacity for refactoring, observability, infra upgrades

• Track technical debt items in backlog and prioritize alongside features

• Tie tech debt to impact metrics (e.g., build failures, performance lag)

Example: Refactored a legacy reporting module that caused 30% of incidents—after 2 sprints, incidents dropped by 80%.

❓ Q7: How do you manage people performance and team culture?

Response:

• Run bi-weekly 1:1s to discuss individual growth, blockers, and feedback

• Encourage squad autonomy but ensure alignment through playbooks

• Conduct sprint health checks and morale retros

• Resolve conflicts via coaching and cross-functional feedback

• Use 360-feedback and quarterly performance snapshots

Example: Helped a struggling team lead improve confidence by pairing with a peer lead and assigning mentorship goals. Resulted in 30% improvement in sprint velocity.

❓ Q8: How do you manage budgeting and resource forecasting in agile programs?

Response:

• Use feature-based estimation during PI planning for forecasting

• Maintain a capacity tracker (story points vs. FTE)

• Track actuals vs. forecast using burndown charts and velocity trends

• Adjust resource mix (contractor vs. FTE) as per program burn rate

Example: Reforecasted Q2 budget after realizing offshore velocity increased by 20%, allowing for a 15% cost saving without reducing scope.

❓ Q9: How do you handle contract/vendor relationships during delivery?

Response:

• Clearly define SoW, SLAs, and success metrics upfront

• Set up weekly vendor syncs to track deliverables and escalate gaps

• Perform QA audits and code quality checks on deliverables

• Use joint demos and shared JIRA boards for transparency

Example: Improved third-party KYC service integration timeline by 2 weeks via collaborative backlog grooming and revised SLAs.

🧾 Interview Storytelling Sheet (Cheat Sheet)

Topic	Key Story/Example
Multi-squad program mgmt	Mutual Fund modernization with 4 squads and shared governance
Cross-squad delivery risk	Mock RTA API, Scrum of Scrums, contract testing
Major incident handling	SIP bug in UAT, WAR room, RCA, hotfix
People leadership	Coached struggling lead, improved velocity
Tech vs. Feature balancing	Refactored reporting module, 80% incident reduction
Vendor management	Improved SLA with external KYC vendor, gained 2 weeks of timeline
Budgeting	Agile forecasting, reduced cost by optimizing offshore velocity
Stakeholder alignment	Business demos, OKRs, CSAT >90%

🧪 Scenario-Based Mock Interview Questions (with Scoring Criteria)

Scenario	What to Evaluate	Scoring Criteria (0–3)
"Your squad missed 2 consecutive sprints. Business is escalating."	Conflict resolution, stakeholder mgmt, retrospective actions	0 = blame game1 = vague retro2 = clear RCA3 = data + improvement plan
"Vendor code has quality issues but is on the critical path."	Vendor handling, quality assurance, risk management	0 = ignore1 = complain only2 = raise + adjust scope3 = add joint QA, code reviews
"Tech debt has grown; team velocity is dropping; features lag."	Prioritization, product negotiation, sustainable delivery	0 = ignore1 = mention tech debt2 = suggest tech% allocation3 = align with KPIs + show ROI
"A conflict arose between two leads over shared microservices."	People management, architecture governance	0 = escalate only1 = patch fix2 = create shared channel3 = define contract + DoR/DoD alignment
"Stakeholders say the metrics dashboard is unclear and delayed."	Communication, visibility, KPI alignment	0 = no data1 = JIRA snapshot only2 = basic dashboard3 = stakeholder-focused OKR board

📊 Stakeholder Storytelling Dashboard Summary (For Executive View)

Metric	Format	Cadence	Notes
Program Progress	% Feature Completion	Weekly	Tracked from JIRA and visualized in Confluence
Sprint Predictability	Planned vs. Delivered SP	Sprint End	Flag when <80%
Escaped Defects	Prod Bugs per Sprint	Sprint End	Show trend line for last 6 sprints
Velocity Trend	Squad-wise Burnup Chart	Weekly	Use Azure DevOps or Excel-based charts
Cross-squad Dependencies	Dependency Matrix Chart	Weekly	Use Miro/Draw.io
Stakeholder Satisfaction	CSAT (% Happy Responses)	Monthly	Google Form/SurveyMonkey results
Release Burndown	PI-Level Burn Chart	Biweekly	Reflect scope vs. velocity
Risk Register Status	Risk Heatmap	Weekly	RAG rating with ownership and mitigation dates

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

Great question. For a Mutual Fund Platform Modernization Program with 4 agile squads, you should track multi-dimensional metrics aligned to delivery, quality, risk, and stakeholder visibility.

✅ Metrics to Track Across the 4 Agile Squads

🚀 1. Delivery & Progress Metrics

Metric	Description	Tool
Feature Completion %	% of committed vs. delivered features	JIRA, Confluence
Sprint Velocity	Story points delivered per sprint	JIRA Velocity Chart
Planned vs. Delivered	Predictability of squads per sprint	JIRA, Burndown
Release Burndown	Tracks PI/Release progress	Excel, JIRA
Epic Progress	Progress at feature level for POs/Stakeholders	JIRA Portfolio

🧪 2. Quality Metrics

Metric	Description	Tool
Escaped Defects	Bugs reported in UAT/Prod	Azure DevOps, Jira
Code Coverage	Unit test % (target ≥ 80%)	SonarQube, JaCoCo
SonarQube Issues	Critical/blocker violations	SonarQube
Defect Leakage %	Test vs. Prod bug ratio	TestRail, Jira

🔐 3. Risk, Dependency & Compliance Metrics

Metric	Description	Tool
Open Risks & Issues	# of program-level risks	Confluence
Dependency Health	# of blocked cross-squad stories	JIRA
Compliance Violations	Static scan + regulatory checklist adherence	Trivy, OWASP, Excel

💬 4. Team & Stakeholder Health

Metric	Description	Tool
Sprint Health Check	Team sentiment, blockers, morale	Google Forms
Stakeholder CSAT	Feedback from PO, Legal, Marketing, etc.	SurveyMonkey
Engagement Score	Attendance, retro participation	Manual/Confluence

📢 Reporting Format, Frequency & Audience

Report Name	Audience	Format	Frequency
Squad Sprint Report	Scrum Master, Team	JIRA Dashboard, Sprint Retro	Biweekly
Program Progress Dashboard	Program Manager, RTE	Confluence + Excel/JIRA Charts	Weekly
Stakeholder Update Deck	Business, CTO, PO	PPT + Visual Metrics	Biweekly/Monthly
Risk & Compliance Report	Risk, Legal, Audit	Excel + Compliance Checklist	Monthly
Release Status Review	QA, DevOps, Architects	Miro, Burn Chart, Release Tracker	Biweekly

🧩 Sample Program Metrics Dashboard Snapshot

Metric	Value	RAG Status
Feature Completion	42%	🟡 Yellow
Escaped Defects (last PI)	3	🟢 Green
Open Risks	6	🔴 Red
Compliance Gaps	1	🟡 Yellow
Sprint Predictability	85%	🟢 Green
Stakeholder CSAT	92%	🟢 Green

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

📅 Program Execution Plan – Mutual Fund Modernization (4 Agile Squads)

🔹 Duration: 9 Months (3 Program Increments)

📌 Phase 1: Initiation & Discovery (Month 1)

• Finalize business outcomes and OKRs (CSAT ↑, TAT ↓)

• Identify stakeholders, 4 agile squads, tech stack, and RTE

• Audit legacy systems and define architecture blueprint

• Set up JIRA, Confluence, Azure DevOps, environments

• Conduct initial PI Planning (define PI#1 objectives for each squad)

📌 Phase 2: Increment 1 – Foundation Build (Months 2–3)

• Squad Sprint Cycles: 3 sprints (2 weeks each) for all 4 squads:

  • Investor Experience Squad: KYC, onboarding UI shell

  • Transaction Services Squad: Setup of order placement engine

  • Advisory Services Squad: Distributor dashboard scaffolding

  • Compliance & Reporting Squad: Logging & audit design

• Infra setup: AKS clusters, API Gateway, Dev/QA

• Begin Scrum of Scrums twice weekly

• Release 0.1 (internal only) + showcase demo to stakeholders

📌 Phase 3: Increment 2 – Integration & Partner Flows (Months 4–6)

• 6 sprints with all 4 squads at full velocity:

  • Investor Squad: Mobile enhancements, dashboarding

  • Transaction Squad: SIP/STP, idempotency logic

  • Advisory Squad: CRM sync, payout engine MVP

  • Compliance Squad: SEBI rules engine, audit APIs

• Integration testing, observability instrumentation

• Nightly regression pipeline via Azure DevOps

• Release 0.2 (limited UAT partners)

📌 Phase 4: Increment 3 – Scale & Compliance (Months 7–9)

• Each of the 4 squads finalizes module integration:

  • Investor Squad: Guardian workflows, multilingual support

  • Transaction Squad: Edge cases, fallback mechanisms

  • Advisory Squad: Live commissions & AUM dashboards

  • Compliance Squad: Tax reporting, Azure Sentinel setup

• Performance testing (JMeter/Gatling)

• Release 1.0 (Production cutover)

• Post-Go-Live Monitoring + stakeholder signoff

🔁 Recurring Activities (Across All 4 Squads)

• Scrum of Scrums: Tue/Fri

• Squad Sprint Reviews: Every 2 weeks

• Squad & Program-level Retrospectives: Monthly

• Risk Register & RAID log: Updated weekly

• PI Planning: Every 3 months (all squads participate)

• Stakeholder Demo + Roadmap Review: Monthly

📊 Tracking & Reporting

• JIRA Dashboards: Squad-specific velocity, epic progress

• Excel/Power BI: Cross-squad KPIs, PI roadmap

• Confluence: DoD, AC, risks, decisions – squad-wise sections

• Miro: Architecture, dependencies, squad swimlanes

🔥 Scenario: Escalation Between Squads Over Shared Microservice Ownership

Context:The Transaction Services Squad and the Compliance & Reporting Squad both depended on a shared "Investor Profile Microservice".

• Transaction Squad wanted to make changes to support edge cases in SIPs (Systematic Investment Plans).

• Compliance Squad required a stricter schema for SEBI audit logging.

They both started making overlapping pull requests. Test failures, deployment clashes, and schema breakages followed.

⚠️ Problem Escalation

• Two squads were blocking each other's pipelines.

• Scrum Masters escalated to the Program Manager (you).

• Business timeline (end of PI 2) was at risk.

✅ Action Plan – How I Handled It

1. Called a Cross-Squad Technical Alignment Meeting

• Included: Tech leads of both squads, architects, POs, and DevOps.

• Outcome: Mapped conflicting use cases on a whiteboard (Miro).

2. Defined Ownership & Boundaries

• Created a shared ownership model:

  • API contract owned by Compliance Squad.

  • Internal logic/processing toggled via feature flags—owned by Transaction Squad.

3. Introduced an API Governance Checklist

• All changes to shared services must:

  • Use versioned endpoints (/v1, /v2)

  • Pass Pact contract tests

  • Trigger a cross-squad code review

4. Added a Program-Level Feature Flag Layer

• Enabled teams to deploy without impacting each other.

• Allowed safe progressive rollout.

5. Escalated Only What Was Necessary

• Raised the need for a dedicated platform squad to the CTO during the PI Demo.

• Approved additional capacity for the next PI.

🎯 Result

Outcome	Impact
Deployment failures eliminated	Pipeline success ↑ to 95%
Squad velocity normalized	Recovered backlog in 2 sprints
New API version released safely	Both squads met PI2 goals
Cross-team collaboration improved	+15% in Sprint Health Survey

🧾 Escalation Story (STAR Format) – Shared Microservice Conflict

✅ Situation

In the Mutual Fund Modernization program with 4 agile squads, both the Transaction Services Squad and the Compliance Squad relied on a shared microservice for investor profile data. Midway through PI 2, both squads began implementing changes simultaneously, causing integration test failures, API contract breakage, and blocking CI/CD pipelines.

✅ Task

As the Program Manager and Delivery Lead, I needed to resolve the technical conflict quickly, realign the teams, and prevent business deliverables from slipping.

✅ Actions Taken

1. Initiated a joint resolution call with Tech Leads, POs, DevOps, and the architect.

2. Mapped requirements live using Miro to surface where each squad’s needs conflicted.

3. Introduced API governance and ownership split:

   • API contract responsibility moved to Compliance Squad.

   • Internal feature logic managed via feature flags by the Transaction Squad.

4. Implemented versioned APIs and mandated Pact-based contract testing.

5. Escalated to the CTO to advocate for a Platform Squad to manage shared assets long-term.

✅ Results

Impact	Outcome
CI/CD Blockers resolved	Deployment stability ↑ to 95%
Team velocity recovered	Backlog normalized within 2 sprints
Both squads delivered on PI goals	🎯 Business timelines were preserved
Cross-squad collaboration improved	Health survey engagement +15%

📄 Interview Sheet Entry (Summary Style)

Theme	Example Used
Escalation Handling	Conflict over shared microservice between Transaction & Compliance Squads
Conflict Resolution	Realigned ownership, implemented versioning & contract testing
Leadership Action	Escalated for structural change → Proposed dedicated Platform Squad
Outcome	Delivery unblocked, velocity recovered, PI goals met

Escalation ID	Category	Date Identified	Description	Impacted Squad	Severity (High/Med/Low)	Owner	Mitigation Plan	Status	Resolution Date
E001	Vendor Delivery Failure	2025-02-10	External KYC API vendor failed to deliver within SLA, impacting onboarding.	Investor Experience	High	Vendor Manager	Escalated to vendor, activated fallback provider, revised SoW with penalties.	Resolved	2025-02-17
E002	Performance Issue	2025-03-03	Team member not meeting delivery goals for 3 consecutive sprints.	Transaction Services	Medium	Delivery Manager	Assigned mentor, introduced weekly goal tracking, flagged in sprint health check.	Monitoring	2025-03-15
E003	Compliance Risk	2025-04-15	Missed SEBI audit checkpoint for onboarding process logging.	Compliance & Reporting	High	Risk & Compliance Lead	Integrated logging checkpoint into CI/CD, added legal review sign-off per sprint.	Open

✅ 1. Vendor Failure – KYC API (STAR Format)

• S: During Sprint 3 of a mutual fund modernization program, the onboarding flow was blocked as the KYC API vendor failed to deliver a stable endpoint, breaching the SLA.

• T: I needed to ensure delivery continuity without compromising quality or Sprint goals.

• A:

  • Escalated the issue to the vendor's leadership team citing contractual SLAs.

  • Activated a fallback mock API for development and testing continuity.

  • Initiated a SoW revision, adding penalty clauses and weekly status checkpoints.

• R:

  • Onboarding flow was restored within 5 working days.

  • Future incidents were avoided through added vendor accountability.

  • System uptime improved to 99.9% for onboarding by next release.

✅ 2. Non-Performing Team Member (STAR Format)

• S: A backend developer in the Transaction Squad underdelivered for three consecutive sprints, impacting sprint goals and peer morale.

• T: I had to resolve the performance issue while keeping the team’s cohesion intact.

• A:

  • Conducted a respectful 1:1 to understand root causes (confidence and unclear expectations).

  • Assigned a senior engineer as a mentor, added pair programming and weekly micro-goals.

  • Reduced story complexity and coached on sprint estimation.

• R:

  • The developer improved by Sprint 3, completing 85% of assigned tasks.

  • Confidence and engagement reflected positively in team retros.

  • Actions and feedback were documented in the formal HR performance cycle.

✅ 3. Missed Compliance Checkpoint (SEBI Requirement)

• S: In Sprint 6, the compliance squad missed implementing a SEBI-mandated audit log in the onboarding flow, which was a hard-go requirement for go-live.

• T: I needed to ensure compliance without derailing our PI2 release timeline.

• A:

  • Halted the production release and raised a release blocker in JIRA.

  • Paired compliance and DevOps to implement audit trail validation directly into the CI/CD pipeline.

  • Initiated weekly checkpoint reviews with the legal/compliance lead.

  • Updated the Definition of Done across squads to include compliance checklists.

• R:

  • Compliance gap was closed in Sprint 7.

  • Future risks were mitigated by automated CI checkpoints and a legal-aligned DoD.

  • Release was delayed by just one sprint with stakeholder alignment.