DevOps Trainer in Bangalore

Why delivery gets slow, framed as queues and batch size rather than culture. Value-stream mapping on a real process, the four delivery metrics and how to measure them from data you already have, and how to write a case for change that survives a budget conversation.

Topics: Value-stream mapping a real change from idea to production · Batch size, queues and hand-off cost · Deployment frequency, lead time, change failure rate, time to restore · Instrumenting metrics from Git, CI and incident data · Where DevOps, SRE and platform engineering divide · Common anti-patterns: a DevOps team that became a new silo

• Assignments: (1) Map your team's current change path and mark every queue and approval; (2) Calculate the four metrics from the last 90 days of real data
• Capstone: Produce a baseline report and a prioritised improvement plan with expected metric impact

Git as the substrate of everything else. Repository structure, branching models compared honestly against release cadence, code review that catches defects without becoming a queue, and the merge and history problems that appear when twenty engineers share a branch.

Topics: Repository layout: monorepo, polyrepo and the trade-offs · Trunk-based development, GitFlow and release branching · Feature flags as an alternative to long-lived branches · Pull request review as a queue you can measure · Merge, rebase and recovering a broken shared branch · Signed commits, protected branches and required checks

• Assignments: (1) Move a team from long-lived branches to trunk-based with feature flags; (2) Measure review latency and identify the actual bottleneck
• Capstone: Define and document a branching and review standard matched to your release cadence

A build that runs on every commit and means something when it passes. Pipeline as code, build caching and speed, test layering, artifact creation and versioning, and quality gates that block a merge rather than producing a report nobody reads.

Topics: Pipeline as code in Jenkins, GitLab CI or GitHub Actions · Build speed: caching, parallelism and agent sizing · Test layers: unit, integration, contract and where each belongs · Artifact versioning and immutable build outputs · Static analysis and coverage gates that hold · Flaky tests and what to do about them honestly

• Assignments: (1) Convert a hand-configured job into a versioned pipeline definition; (2) Halve a build time using caching and parallelism and record the measurement
• Capstone: Deliver a CI pipeline that produces a versioned, tested artifact on every commit to mainline

Environments produced from code so they are reproducible and disposable. Terraform for provisioning with remote state and locking, Ansible for configuration, environment parity, and the change-review discipline that makes an infrastructure diff readable before it is applied.

Topics: Terraform: providers, state, locking, modules and workspaces · Reviewing a plan as a change proposal · Ansible for configuration on top of provisioned infrastructure · Environment parity and what may legitimately differ · Secrets: where they live and how they reach an application · Disposable environments for testing and their cost control

• Assignments: (1) Provision an identical environment twice from code and diff the results; (2) Add a plan-and-review gate to an infrastructure pipeline
• Capstone: Build one environment entirely from code, destroy it, and rebuild it identically

Packaging and running the artifact. Images built for size, speed and provenance; a registry that acts as the promotion boundary; then Kubernetes for deployment, configuration, service exposure and the rollout strategies that make a release reversible.

Topics: Dockerfiles built for cache behaviour and small runtime images · Registry as the promotion boundary between environments · Kubernetes Deployments, Services, Ingress and configuration · Rolling, blue-green and canary releases · Readiness and liveness probes that reflect reality · Rollback: what it does and does not undo

• Assignments: (1) Package an application and promote the identical image through three environments; (2) Perform a canary release and roll it back under load
• Capstone: Deploy an application to Kubernetes with a chosen rollout strategy and a rehearsed rollback

Knowing production is healthy before a user tells you. Metrics, logs and traces and what each is for, service level objectives and error budgets, alerts that page a human only when it matters, and the incident and post-incident practice that closes the loop back into the backlog.

Topics: Metrics with Prometheus and dashboards that answer a question · Structured logging and centralised search · Distributed tracing and where latency actually goes · SLIs, SLOs and error budgets · Alert design and reducing pager noise · Incident response, blameless review and feeding fixes back

• Assignments: (1) Define an SLO for one service and an alert that fires only on user impact; (2) Run a post-incident review on a real or simulated failure
• Capstone: Instrument a service end to end and detect a deliberately introduced regression from telemetry alone

Moving checks left without stopping delivery. Dependency and container scanning, static analysis, secrets detection, image provenance and signing, and the policy question of what fails a build versus what raises a ticket — plus how to introduce all of it without a mutiny in week one.

Topics: Dependency scanning and reachable-vulnerability triage · Static analysis and quality gates on new code · Secrets detection and rotating what has already leaked · Container image scanning and base image governance · Signing, provenance and a software bill of materials · Phased enforcement and an exception process that stays honest

• Assignments: (1) Add three security gates to a pipeline and tune them to a tolerable false-positive rate; (2) Detect and rotate a leaked credential end to end
• Capstone: Deliver a pipeline with security gates the development team accepts and does not route around

Turning one team's good practice into an organisation's default. Golden paths, shared pipeline libraries and self-service infrastructure; team topologies and where ownership sits; adoption sequencing; and the review cadence that keeps the delivery metrics moving after the training ends.

Topics: Golden paths and paved roads versus mandated tooling · Shared pipeline libraries and reusable modules · Self-service infrastructure and guardrails · Team topologies: stream-aligned, platform and enabling teams · On-call ownership and the you-build-it-you-run-it boundary · Sequencing adoption across many teams without stalling delivery

• Assignments: (1) Design a golden path for one service type and identify what it removes from product teams; (2) Write the adoption sequence for three teams with different starting points
• Capstone: Produce a 90-day delivery improvement plan with owners, measures and a review cadence