Platform Engineer

We need to output HTML fragment with sections: About the role? Actually the posting includes sections: WHAT MAKES US A GREAT PLACE TO WORK, WHO YOU’LL WORK WITH, WHERE YOU’LL FIT WITHIN THE TEAM, WHAT YOU'LL DO, ABOUT YOU, U.S. COMPENSATION INFORMATION, etc. We must use

for section headings (e.g., About the role, Responsibilities, Requirements, Qualifications, Skills, Benefits, Pay, Schedule). However we need to map content to appropriate headings. The instructions: Use

for section headings (e.g. About the role, Responsibilities, Requirements, Qualifications, Skills, Benefits, Pay, Schedule). Use

• for any list of duties/requirements/benefits, and

  for prose. Do NOT repeat the job title as a heading (the page already shows it) and do NOT put Job ID / requisition numbers as headings — fold minor metadata into a short

  or drop it. Preserve ALL substantive information; do NOT invent or summarize away detail. Remove cookie/navigation/legal/EEO/equal-opportunity/scam-warning boilerplate, duplicated lines, and application instructions. IMPORTANT: include a section ONLY when the posting has real, specific content for it — never emit a heading followed by filler/placeholder text (e.g. "commensurate with experience", "not specified", "N/A", "varies", "TBD") and never create Pay/Schedule/Benefits sections unless the posting actually states them. Prefer a few substantive sections over many thin ones. Output ONLY the HTML fragment — no /, no markdown code fences. Thus we need to decide which sections to include based on content. We have content about company culture (WHAT MAKES US A GREAT PLACE TO WORK) – could be "About the role"? Actually "About the role" is generic; but we could use "About the team" or "Company overview". However the instruction says use headings like About the role, Responsibilities, Requirements, Qualifications, Skills, Benefits, Pay, Schedule. It doesn't forbid other headings? It says use

  for section headings (e.g. About the role, Responsibilities, Requirements, Qualifications, Skills, Benefits, Pay, Schedule). Likely they expect those headings only. So we should map content to those categories. We have: - About the role: maybe the description of role, team, mission. Could be "About the role" covering WHAT MAKES US A GREAT PLACE TO WORK, WHO YOU’LL WORK WITH, WHERE YOU’LL FIT WITHIN THE TEAM. - Responsibilities: WHAT YOU'LL DO (core duties). - Requirements: ABOUT YOU (education, experience). - Qualifications: maybe overlapping with Requirements; but we could combine. - Skills: maybe list of technical skills (Python, FastAPI, Postgres, etc.) from ABOUT YOU. - Benefits: U.S. COMPENSATION INFORMATION includes compensation, bonus, 401k, benefits. - Pay: maybe we could separate Pay from Benefits? But they said only create Pay section if posting actually states them. The posting includes salary ranges and compensation details. So we could have a Pay section with salary ranges and bonus, 401k. - Benefits: could include medical, dental, vision, PTO, etc. - Schedule: hybrid model requiring in-office presence at least 1 day per week. Thus we can create sections: About the role, Responsibilities, Requirements, Skills, Pay, Benefits, Schedule. We must not repeat job title as heading. No Job ID. We must use

  • for any list of duties/requirements/benefits. So for responsibilities we should list bullet points. For requirements/qualifications/skills also bullet lists. We must preserve all substantive information; not invent or summarize away detail. So we need to include all details from the posting, but we can format as bullet points. We must remove boilerplate: cookie/navigation/legal/EEO etc. The posting didn't have obvious boilerplate besides maybe the "WHAT MAKES US A GREAT PLACE TO WORK" which is fine. We need to ensure we don't create sections with filler text. All sections have content. Now we need to extract content. Let's parse the posting: WHAT MAKES US A GREAT PLACE TO WORK - Paragraph about being top ranked consulting firm on Glassdoor, etc. - Paragraph about extraordinary teams, intentional focus, inclusive environment, hire exceptional talent, thrive. WHO YOU’LL WORK WITH - Description: premier consulting partner for private equity industry, Bain's PEG global practice >3x larger than any competitor, network of over 1,000 professionals supports PE and institutional investor clients through investment life cycle. - Bain & Company developing suite of cutting-edge data and software solutions designed to revolutionize how PE uses data for investment insights and decision-making. PEG Innovation team's mission: create analytical solutions for Bain clients, teams, broader institutional investor space using proprietary software and data products. Includes development, commercialization, daily management of Bain's proprietary datasets, data, and software businesses. WHERE YOU’LL FIT WITHIN THE TEAM - Platform Engineers build and maintain shared backend services that power Bain Diligence Platform (BDP). Includes enterprise SSO, session management, audit, case and case-provenance APIs, document and file access (Microsoft Graph/SharePoint and Azure Blob Storage), search with source citations, API gateway. - Contribute to services across full delivery lifecycle — design, build, test, deploy, monitor, operate — with guidance from senior engineers. - Write reliable, well-tested code, follow platform engineering standards, help ensure services are secure-by-default, observable, production-ready. - Collaborate closely with Platform, Data & Intelligence, Security, Infrastructure teammates to deliver shared capabilities stable, scalable, easy for squads to consume as platform hardens. WHAT YOU'LL DO Core Platform Service Development, Deployment, and Operations (80%) - Implement backend features and service endpoints in existing platform services under guidance of senior engineers. - Build and maintain REST APIs in FastAPI using clear contracts, input validation, consistent error handling. - Write and update Postgres schemas and Alembic migrations using safe patterns (including backwards-compatible changes) with review support. - Use Redis for standard platform patterns such as caching, session storage, rate limiting under established conventions. - Use event-driven integration where asynchronous behaviour adds clear value (e.g., change feeds and domain events, following existing schema and envelope conventions), consistent with platform's simple-now, evolve-when-needed approach. - Add and maintain service instrumentation: structured logs, OpenTelemetry-style spans, Datadog metrics and APM traces according to platform standards. - Update and maintain Helm chart values and Kubernetes manifests for services deployed to Azure Kubernetes Service (AKS); ensure probes, resource requests/limits, environment configuration correct, support blue/green candidate/promote deployments. - Contribute to Terraform infrastructure-as-code for Azure, deployed through env0 / Terraform Cloud across dev, UAT, prod environments, with review support. - Work within GitHub Actions pipelines: pull-request test suites, branch-to-environment promotion (main → Dev, release/X.Y → UAT/Prod), image publishing to Cloudsmith, and blue/green candidate/promote deploys with approval gates. - Triage and resolve routine production issues for owned services; participate in on-call rotation with support and follow established runbooks. - Write and update runbooks and service documentation for changes you ship, ensuring operational steps remain accurate. Other (20%): - Participate in code reviews as both author and reviewer; incorporate feedback and apply engineering standards consistently. - Use AI coding assistants to accelerate boilerplate creation (routers, schemas, tests, docs); review all generated code and align it with platform conventions before committing. - Use LLMs to draft first-pass documentation (runbook updates, service notes, API docs); validate and refine outputs before publishing. - Collaborate with Security and Infrastructure on implementation tasks (e.g., Azure Key Vault secret consumption, Entra ID app registrations, network-security-group / private-endpoint constraints, least-privilege configuration, and Wiz security-scan findings) under guidance. - Contribute to quality improvements (test coverage, refactors, observability, and reliability fixes) as part of regular delivery work. ABOUT YOU - Bachelor’s degree in Computer Science, Engineering, Information Systems, or a related field (or equivalent practical experience) - 2+ years of experience building backend services, APIs, or platform components in a production or near-production environment. - Demonstrated experience building and maintaining backend services or APIs with an emphasis on reliability and correctness. - Experience contributing to REST APIs and working with relational databases (Postgres preferred), including basic schema evolution and migration workflows. - Exposure to containerised development and deployment practices (Docker) and familiarity with operating services in Kubernetes environments (Azure / AKS in practice). - Exposure to authentication and authorisation concepts (JWT, RBAC, OIDC/SAML — Entra ID / Azure AD in practice) and interest in building secure-by-default services. - Demonstrated ability to learn from feedback, collaborate effectively, and deliver production-ready work within established engineering standards. - Backend / platform engineering - Proficient Python development skills; able to build FastAPI services using Pydantic, write tests with pytest, and follow linting/type-checking standards (Ruff, mypy), and manage environments and dependencies with uv. - Working knowledge of Postgres fundamentals: schema design basics, indexing concepts, and safe migration practices with Alembic. - Working knowledge of Redis patterns for caching and session storage; understands basic failure modes and operational considerations. - Familiarity with event-driven integration patterns applied where asynchronous behaviour adds value (change feeds / domain events, consumers, retries, idempotency); able to implement producers/consumers within established conventions. - Docker proficiency for local development and building container images; understands non-root execution and basic image hygiene. - Kubernetes fundamentals: understands deployments/services, pod lifecycle basics, and how health checks and resource limits affect service behaviour; able to work with Helm values and charts on AKS, including blue/green deployments. - Observability fundamentals: structured logging, tracing concepts, and emitting metrics and APM traces via Datadog for service health; awareness of MLflow for evaluating AI features. - Security fundamentals: understands least-privilege access, secret-handling basics, and common authN/authZ concepts; follows established patterns for JWT and RBAC integration, Entra ID, and Azure Key Vault. - Familiarity with infrastructure-as-code (Terraform) and CI/CD via GitHub Actions; understands environment promotion, container registries (Cloudsmith), Helm chart versioning, and blue/green deployments on AKS. - Generative AI and agentic systems - Uses AI coding assistants (Cursor, GitHub Copilot, or equivalent) to accelerate development tasks (boilerplate, refactors, basic tests); reviews all outputs critically before committing. - Uses LLMs to draft first-pass unit tests and documentation; validates correctness, adds missing edge cases, and ensures alignment with platform standards. - Understands how core platform services (SSO/JWT authentication, RBAC, audit, and case provenance) underpin agentic systems, and why access control, auditability, and provenance matter for AI interactions — including the platform's “skills orchestrate, agents execute” model. - Familiarity with the LLM-application patterns used on the platform: an LLM gateway (Portkey) for model access and routing, structured / tool-constrained outputs with schema validation and automatic repair, and retrieval-grounded answers with citations back to source. - Exposure to eval-driven development for AI features — building evaluation cases and using MLflow to measure quality, regressions, and repair uplift before promoting changes. - General - Treats every service change as production-impacting: writes tests, adds observability where needed, and updates documentation and runbooks. - Raises risks early (unclear requirements, security concerns, migration risk, operational impact) and seeks help