Skip to content
HM

Pune, Maharashtra, India

Harish Mahamure

Senior Software Architect | Staff+ Engineer | AI Systems Architect

Designing high-scale enterprise platforms, AI-powered applications, and cloud-native distributed systems.

Contact MeDownload ResumeView Projects

About

Architecting systems that scale

Senior Software Architect with 8+ years of experience designing and building high-scale enterprise platforms, SaaS products, AI-powered applications, and cloud-native distributed systems.

Currently leading architecture and engineering initiatives at Bajaj Finserv Health in Pune, driving modernization of critical healthcare platforms, designing scalable microservice ecosystems, mentoring engineering teams, and collaborating across multiple business units.

Grew through the Bajaj Finserv Health engineering ladder — SDE → Web Lead → Senior Web Lead → Senior Software Architect — and spent a chapter as Co-Founder & CTO at DooGraphics, building DesignTemplate and scaling through high-traffic product moments.

Experienced in systems that serve millions of requests with reliability, observability, and operational excellence. Passionate about AI engineering, distributed systems, Rust, and shipping products from zero to production. I build with agentic codebases and spec-driven Cursor workflows so teams get higher quality at scale — not just faster output.

Education: Bachelor's Degree in Computer Science

Harish Mahamure

Core strengths

Software ArchitectureDistributed SystemsAI Platforms & LLM ApplicationsAgentic EngineeringSpec-Driven DevelopmentCursor WorkflowsCloud Native EngineeringPlatform ModernizationHigh Performance APIsEngineering LeadershipPerformance OptimizationCost OptimizationDeveloper PlatformsMicroservicesProduct Engineering

Experience

Professional journey

Leading architecture and engineering across enterprise healthcare platforms.

  1. Senior Software Architect

    Bajaj Finserv Health

    Current

    Leading architecture, modernization, and platform engineering initiatives across multiple enterprise healthcare products.

    • Own end-to-end architecture for multiple enterprise healthcare platforms.
    • Drive modernization of legacy applications into cloud-native microservices.
    • Design scalable APIs capable of handling high concurrent traffic.
    • Lead architectural reviews across squads.
    • Mentor engineering teams on software design, scalability, and engineering excellence.
    • Build engineering standards, deployment strategies, and platform governance.
    • Drive observability, resiliency, SLI/SLO adoption, and production reliability.
    • Collaborate with product, business, DevOps, security, and infrastructure teams.
    • Introduce AI-assisted engineering workflows and developer productivity improvements.

  2. Co-Founder & CTO

    DooGraphics

    Co-founded and led engineering for DesignTemplate, a design platform for creators, building product and infrastructure from the ground up.

    • Owned technical strategy and architecture as Co-Founder & CTO.
    • Built and scaled DesignTemplate for creators and design workflows.
    • Led engineering through high-traffic events, including post-Shark Tank scale on DesignTemplate.
    • Hardened delivery with Cloudflare edge caching, performance tuning, and cloud infrastructure.
    • Shipped product features across frontend, backend, and design tooling.

  3. Senior Web Lead

    Bajaj Finserv Health

    Led web engineering for healthcare portal experiences, raising quality, delivery cadence, and frontend standards.

    • Led cross-functional web delivery for enterprise healthcare portals.
    • Drove React and TypeScript standards, code quality, and reusable component patterns.
    • Partnered with product and design on high-impact user journeys.
    • Mentored engineers and improved release reliability.

  4. Web Lead

    Bajaj Finserv Health

    Led web squads delivering customer and partner-facing healthcare experiences.

    • Owned delivery for key web modules and portal features.
    • Improved frontend performance, accessibility, and maintainability.
    • Collaborated with backend teams on API contracts and integration quality.

  5. Software Development Engineer

    Bajaj Finserv Health

    Built production features across healthcare web platforms with strong ownership and delivery focus.

    • Delivered React and JavaScript features for enterprise healthcare products.
    • Took end-to-end ownership of features from design through production support.
    • Collaborated closely with QA, product, and peer engineers to ship reliably.

  6. Module Lead

    Talent Sketchers

    Led module-level delivery for digital engineering and application development workstreams.

    • Owned module delivery, coordination, and technical execution.
    • Worked across web and application development for client engagements.

Enterprise Work

Work highlights

Architecture and delivery across critical healthcare platforms at Bajaj Finserv Health.

Universal Provider Portal (UPP)

Architected a unified healthcare provider platform serving hospitals, TPAs, and insurance partners.

  • Client-side PDF generation
  • Multi-layer gateway caching
  • HTTP cache headers
  • Build-time gzip compression
  • Unified Provider Platform
  • Common Authentication
  • Multi-tenant architecture
  • Hospital onboarding workflows

Healthcare Portal Modernization

Led modernization of multiple enterprise portals including Employee, HR, Agent Management, Investigation, and Provider Management systems.

  • Investigation hybrid architecture
  • EAV to NoSQL migration
  • Device tier optimization
  • Reduced operational complexity
  • Improved deployment frequency
  • Standardized platform architecture
  • Improved reliability
  • Modern cloud-native deployment

AI Powered Surgery Assistance Platform

Architected an AI-assisted surgery recommendation and search platform.

  • Healthcare tariff search
  • Intelligent surgery discovery
  • High-speed search architecture
  • Lightweight search indexing
  • AI-assisted recommendations
  • Low-latency API architecture

Engineering Platform Improvements

Led initiatives around feature flags, release engineering, observability, search discoverability, and performance.

  • Cost reduction engineering
  • Multi-layer gateway caching
  • Build-time gzip compression
  • HTTP cache headers
  • Feature Flag Platform
  • Release Engineering
  • Deployment Pipelines
  • Observability & Monitoring

Personal Projects

Building beyond the day job

Products designed and shipped as founder, architect, and lead engineer.

Founder • Architect • Lead Engineer

Arena360 GameZone SaaS Platform

Multi-app SaaS for gaming cafés — Android, Tauri kiosk, staff/admin apps, inventory, Windows debloater, AI insights, and real-time ops.

RustTauriAndroidPostgreSQLAI Agents

View project

Architect • Engineer

UltraConvert Tools

71 privacy-first browser tools — PDF, image, text, encoders, and converters. Zero uploads; WASM + WebGPU run entirely on-device.

WebAssemblyWebGPUWeb WorkersPWA

View project

Skills

Technical toolkit

Architecture, backend, AI, cloud, observability, and cost-performance engineering — applied across enterprise and product work.

Architecture

Software ArchitectureDomain Driven DesignEvent Driven SystemsDistributed SystemsMicroservicesAPI DesignMulti-tenancyCQRSClean Architecture

Cost & Performance Engineering

Cost Reduction EngineeringClient-Side PDF GenerationInvestigation Hybrid ArchitectureDevice Tier StrategyEAV to NoSQL MigrationBuild-Time gzip CompressionHTTP Cache HeadersMulti-Layer Gateway Caching

Backend

RustJavaNode.jsSpring BootAxumExpressREST APIsGraphQL

Frontend

ReactReact NativeExpoNext.jsTauriAndroidTypeScriptHTMLCSS

Databases

PostgreSQLOracleRedisElasticsearchTypesenseMySQLNoSQL

Cloud & DevOps

DockerKubernetesAzureAWSNGINXGitHub ActionsCI/CDLinux

AI

Large Language ModelsAI AgentsLocal AI DeploymentRAGPrompt EngineeringVector SearchMCP IntegrationsOllamallama.cppvLLMComfyUI

AI Engineering Workflow

CursorSpec-Driven DevelopmentAgentic CodebasesCursor RulesMCP IntegrationsRequirements → Implementation PipelineArchitecture Decision Records (ADRs)Multi-Agent WorkflowsBrownfield Code GraphEnterprise Vector RepositoryFeature & Service MappingMulti-Repo RAG

Observability

OpenTelemetryGrafanaPrometheusHyperDXLoggingMetricsDistributed Tracing

Leadership

Engineering leadership

Ownership, mentorship, and platform strategy across multi-product organizations.

  • Architecture ownership across multiple products
  • Technical strategy and roadmap planning
  • Mentoring senior engineers and technical leads
  • Cross-functional stakeholder management
  • Engineering process improvements
  • Platform standardization
  • Performance engineering
  • AI adoption strategy
  • Spec-driven and Cursor-rules workflows at scale
8+ Years of Software Engineering ExperienceEnterprise Software ArchitectStaff+ Engineering MindsetAI Systems BuilderCo-Founder & CTO ExperienceCloud Native ArchitectDistributed Systems ExpertSpec-Driven Agentic EngineeringPerformance Engineering EnthusiastProduct BuilderEngineering Mentor

AI Engineering

How I build with agentic codebases

Cursor and AI agents are force multipliers — not replacements for architecture judgment. I use spec-driven pipelines and project rules so teams ship faster without sacrificing quality at scale.

  1. 01

    REQUIREMENTS.md

    Clarify goals, acceptance criteria, MoSCoW priorities

  2. 02

    STACK.md

    Lock language, runtime, repo layout, and testing strategy

  3. 03

    SPEC.md

    Freeze behavioural contracts, APIs, data models, edge cases

  4. 04

    PLAN.md

    Module design, integration points, failure modes

  5. 05

    TASKS.md

    Atomic, testable work units for the implementer

  6. 06

    Cursor Agent

    Implement → review → iterate with rules as guardrails

Cursor workflow

Plan mode first, then freeze the spec before any agent writes production code.

  • Plan mode for architecture trade-offs before implementation
  • Spec freeze so agents execute against clear contracts
  • Task decomposition into independently testable units
  • Implement / review loop with blast-radius awareness

Cursor rules at scale

Project rules encode engineering standards so every agent and engineer gets the same bar.

  • API design standards (REST, GraphQL, auth, pagination)
  • Database design (schema, migrations, indexing)
  • System design and impact analysis
  • Production-grade code (KISS, DRY, SOLID, security)
  • UX and accessibility standards

Quality at scale

Rules and specs turn ad-hoc prompting into a repeatable engineering system.

  • Consistent patterns across squads and products
  • Fewer regressions from unclear requirements
  • Faster onboarding — the repo teaches the process
  • Architecture judgment stays human; agents amplify execution

Outcomes

Measurable gains when agentic workflows meet real product delivery.

  • Higher delivery velocity without quality debt
  • Stronger alignment between product intent and code
  • Reusable playbooks for greenfield and brownfield work
  • AI adoption that fits enterprise governance

Markdown artifact flow

The normal path is a sequence of markdown files with human gates between phases. Agents read and write these artifacts — they do not invent product behaviour mid-build.

  1. Step 01

    REQUIREMENTS.md

    User stories, acceptance criteria, scope boundaries, and MoSCoW priorities.

    Who: Human + requirements analystGate: Refine signed off — no code yet

  2. Step 02

    STACK.md

    Language, runtime, repo layout, testing strategy, and deploy constraints.

    Who: Human + tech-stack advisorGate: Stack locked before design

  3. Step 03

    SPEC.md

    Frozen behavioural contracts — APIs, data models, state transitions, edge cases.

    Who: Spec writerGate: Spec freeze — source of truth

  4. Step 04

    PLAN.md

    Modules, integration points, failure modes, and risks (graph-aware on brownfield).

    Who: ArchitectGate: Plan signed off

  5. Step 05

    TASKS.md

    Atomic, ordered, independently testable work units for implementers.

    Who: Task plannerGate: Tasks ready for build

  6. Step 06

    REVIEW.md

    Pass/fail against SPEC, PLAN, standards, and blast radius.

    Who: Reviewer agent or humanGate: Review gate before merge

Scaling agentic delivery

Bigger codebases need bounded contexts, phased tasks, multi-agent roles — and at 100+ repos, a server vector repository so LLMs can answer questions across features and services.

Small vs large project

Same MD artifacts — different depth. Small projects run the pipeline once; large ones phase it.

  • Small: REQUIREMENTS → SPEC → TASKS → one Cursor agent session
  • Large: bounded contexts per module, phased TASKS.md by milestone
  • Brownfield first — detect mode and update the code graph before planning
  • STACK.md defines monorepo/workspace layout; PLAN.md names packages that change
  • MCP servers for docs, CI, and trackers — agents read schemas before calling tools

Multi-agent roles

Specialized agents with human gates beat one mega-prompt for platform-scale work.

  • Requirements analyst → tech-stack advisor → spec writer
  • Architect → task planner → implementer → reviewer
  • One TASKS.md item = one focused agent session — never “build the platform”
  • Blast-radius review: affected callers, tests, and integration points
  • Shared Cursor rules layer + repo-specific rules for every agent

Server vector repository

At 100+ repos, local context is not enough. A server-side vector store plus feature/service maps keep enterprise knowledge queryable for agents and humans.

  • Centralized embeddings for code, docs, ADRs, and runbooks across many repos
  • Continuous indexing with service ownership and domain metadata on chunks
  • Feature → service → repo → API maps for blast radius and issue hunting
  • LLM + RAG answers architecture and ops questions with grounded citations
  • Cursor/MCP agents query the same store during plan, implement, and review

Architecture Decision Records

Significant trade-offs live in docs/adr — not buried in chat history. ADRs freeze judgment so agents implement decisions instead of re-litigating them.

docs/adr/ADR-NNN-title.md

Lifecycle: Proposed → Accepted → Deprecated | Superseded by ADR-XXX

When to write an ADR

  • Choosing a database or storage technology
  • Defining service or module boundaries
  • Selecting a framework or major library
  • Security architecture choices
  • Significant infrastructure or deployment changes

How ADRs connect to the MD flow

  • PLAN.md references ADRs for module boundaries and integration choices
  • SPEC.md implements accepted ADRs — agents do not reopen frozen decisions
  • New trade-offs mid-build → write a new ADR before changing direction
  • Superseded ADRs link forward so history stays navigable

ADR template

# ADR-NNN: [Title]
Status: Proposed | Accepted | Deprecated | Superseded
Date: YYYY-MM-DD

## Context
## Decision
## Consequences (Positive / Negative / Risks)
## Alternatives Considered
## Implementation Notes

Toolchain

CursorSpec-Driven DevelopmentAgentic CodebasesCursor RulesMCP IntegrationsAI AgentsLocal LLMsRAGArchitecture Decision RecordsVector SearchEnterprise RAGService Mapping

Deeper write-up: Spec-driven agentic development with Cursor

Recognition

Awards & recognition

Bajaj Finserv Health

The Transformer Award

Recognized for leading the modernization of multiple enterprise healthcare platforms, driving architectural transformation, improving engineering efficiency, and successfully delivering strategic initiatives including Universal Provider Portal and large-scale portal modernization.

View certificate

Contact

Let's work together

Open to architecture consulting, staff+ engineering conversations, and interesting product collaborations.

Get in touch

Prefer email or a quick call? Use the links below — no form required.

Email meCall +91 70286 01207