Corporate · onsite · online training worldwide
contact@DevOpsSchool.com· +91 99057 40781·
> Continuous Integration · DevOpsSchool Trainer

Concourse Trainer

Private corporate batches, live online cohorts and 1-on-1 mentoring in declarative pipelines-as-config, containerised steps and versioned resources with no mutable build state — taught by a practitioner who runs it in production.

20 years across DevOps, SRE and Security · 10,000+ engineers trained · Trained teams at JPMorgan Chase, Verizon, Nokia and the World Bank

DeliveryOnline · Onsite · Hybrid
FormatsCorporate · 1-on-1 · Cohort
AgendaCustomisable
Batch size8–30 engineers
Engineers we've trained work at
JPMorgan ChaseBank of AmericaWells FargoVerizonNokiaWorld BankGE HealthcareVMwareOracleQualcommMercedes-BenzAirbusDatadogSplunkDeloitteInfosysWiproCapgemini
# who teaches it

Your Concourse trainer

Rajesh Kumar

Principal DevOps Engineer & Architect

Build & release engineeringPipeline designMulti-org CI estates20 years in productionPrincipal / architect roles10,000+ engineers trainedM.Tech BITS Pilani25+ certifications

Rajesh teaches Concourse from its model outward — resources and versions before syntax, the passed constraint as the mechanism that makes promotion provable, and tasks as containers with declared inputs and outputs rather than shell scripts on a shared machine. Sessions cover fly hijack and intercept for live debugging inside a failing container, credential managers with Vault and CredHub so nothing sensitive lives in the pipeline file, writing a custom resource type from its check, in and out scripts, and operating the web and worker fleet including drains, garbage collection and database care.

Twenty years across DevOps, SRE and Security, in principal and architect roles at PayPay, SoftwareAG, ServiceNow, JDA Software, Intuit, Adobe and others. He has trained engineers at JPMorgan Chase, Verizon, Nokia, the World Bank, VMware, Oracle, Mercedes-Benz and Airbus — more than 10,000 people personally. He teaches what he runs, not what he reads.

One practitioner, not a bench

You are booked with a named engineer, and that is who turns up. Marketplaces and larger providers rotate whoever is free, so the person who sold you the agenda is rarely the person teaching it.

The same trainer is available for the next engagement, which matters when a team builds on what it learned last time.

18,000+certified learners
500+corporate batches delivered
50+countries served
100+certification programmes
# faculty

Who delivers Concourse engagements

Your batch is assigned a named trainer before it starts, and that is who teaches it. See the full faculty.

How your Concourse trainer is chosen

Engagements are matched on the tool, not the calendar. For Concourse that means a trainer who has run it in production — declarative pipelines-as-config, containerised steps and versioned resources with no mutable build state — rather than whoever is free that week. You are told who is teaching before you commit, and that person is on the discovery call that shapes the agenda.

Where a batch is large enough to need a second trainer, the pairing is declared up front. The lead trainer stays accountable for the syllabus and the assessment either way.

Rajesh Kumar

Principal DevOps Engineer & Architect

India20 yrsLead trainer

Twenty years across DevOps, SRE and Security in principal and architect roles at PayPay, SoftwareAG, ServiceNow, JDA Software, Intuit, Adobe, IBM/Emptoris, Ness, MindTree and Accenture. He has trained more than 10,000 engineers personally, at organisations including JPMorgan Chase, Verizon, Nokia, the World Bank, VMware, Oracle, Mercedes-Benz and Airbus. He teaches what he runs, not what he reads.

Pranab Kumar

IndiaInstructorCoach

Rohit Ghatol

IndiaInstructorCoach

Amit Agarwal

IndiaInstructorCoach

Anil Kumar

IndiaInstructorCoach

Balachandran Anbalagan

IndiaInstructorCoach

Durga Prasad

IndiaInstructorCoach

Gaurav Aggarwal

IndiaInstructorCoach

Harsh Mehta

IndiaInstructorCoach

Kapil Gupta

IndiaInstructorCoach

Kunal Jain

IndiaInstructorCoach

Nikhil Gupta

IndiaInstructorCoach

# how to engage

Four ways to work with this trainer

Private corporate batch

Teams of 8–30

Custom agenda, your timezone, onsite or online, NDA-friendly.

Request a quote

1-on-1 mentoring

Individual engineers

A private instructor and a curriculum built around your goal.

₹99,999

Live & Interactive cohort

Individuals who want peers

Scheduled batch, max 8 to 10 hours of live instruction.

₹34,999

Self-paced video

Self-starters

Full LMS access — 20+ courses and 50+ tools included.

₹833/mo
# private batches

Private Concourse training for your team

A private batch starts with a discovery call. We look at the stack you actually run — the CI system, the cloud, the constraints — and map the agenda onto it, so examples use your topology rather than a generic one.

Delivery is onsite at your premises, live online, or hybrid, scheduled around your release calendar rather than ours. Batches run 8 to 30 engineers.

Every attendee leaves with recordings, slides, lab repositories and a completion certificate. You receive an attendance and assessment report. Invoicing supports PO and GST.

Talk to us about a private Concourse batch

What you provide vs what we bring

  • You: the room or the call, and the engineers
  • Us: trainer, agenda, labs, assessment, certificates
  • Labs: we guide your team through provisioning their own free-tier cloud environment — the skill goes with them
# the technology

What is Concourse?

Concourse is an open-source continuous integration system built on a deliberately narrow set of ideas. There are no plugins, no jobs configured through a web form, and no mutable state on a build machine. A pipeline is a YAML document that you push to the server with the fly CLI, and everything the pipeline touches is either a resource — an external, versioned thing such as a Git repository, an S3 object or a container image — or a task, which is a container with declared inputs, declared outputs and a command to run.

That design produces two properties most CI systems cannot offer. The first is reproducibility: because every task declares its own image and its own inputs, a build cannot accidentally depend on something a previous build left behind on the worker. The second is the passed constraint, which is Concourse's genuinely distinctive feature. When a job says it wants a version of a resource that has passed through an earlier job, Concourse tracks version propagation across the whole pipeline graph, so the artifact you deploy is provably the same one that was tested rather than a rebuild that happens to share a commit.

Architecturally Concourse is small: a web node running the ATC scheduler, API and UI, a TSA gateway that workers register through over SSH, a fleet of stateless workers running containers, and PostgreSQL holding all the state that matters. Workers are cattle — drain one and rebuild it. Credentials never live in the pipeline file; they are interpolated at runtime from Vault, CredHub, AWS Secrets Manager or Kubernetes secrets. Teams provide multi-tenancy with role-based access, and the set_pipeline step lets pipelines configure themselves from source control.

Why this skill matters now

Concourse solves a problem that becomes acute at scale: CI estates that drift because build machines accumulate state and configuration lives in a database rather than in Git. Once you have hundreds of pipelines, the ability to delete every worker and rebuild the whole system from YAML and a Postgres backup stops being an aesthetic preference and becomes an operational requirement.

It is also the system of choice where release provenance is scrutinised. Regulated platform teams, infrastructure providers and anyone shipping software other people run in production need to demonstrate that the binary going to production is the exact version that passed the security scan and the integration suite. The passed constraint answers that directly, in a way that a pipeline built from independent jobs sharing a workspace does not.

The learning curve is the honest reason training is bought. Concourse asks engineers to think in versioned resources and immutable containers rather than build steps on a machine, and teams that approach it as "YAML Jenkins" produce pipelines that fight the tool. The gap between a working pipeline and an idiomatic one is large, and it shows up as slow builds, custom resource types that should never have been written, and credentials pasted into the pipeline file.

Concourse training
# outcomes

What your team can do afterwards

Write a complete pipeline as declarative YAML and manage it entirely through fly set-pipeline
Model external state correctly with resources and resource types instead of scripting fetches by hand
Use the passed constraint to guarantee that what deploys is exactly what was tested
Author tasks as containers with explicit image, inputs and outputs, so builds are reproducible
Debug a failing build from inside its container with fly intercept rather than adding echo statements
Keep credentials out of pipeline files using Vault, CredHub or a cloud secrets manager
Structure multi-team estates with teams, RBAC roles and self-updating set_pipeline workflows
Operate a Concourse cluster — worker lifecycle, draining, garbage collection, upgrades and Postgres care
# curriculum

8 modules. Live demos in a real lab, not slides.

01The Concourse model — resources, jobs and versionsLive & Interactive5 hrs · 2 assignments · 1 capstone

The mental model before any YAML. Why Concourse has no plugins and no mutable worker state, what a resource actually is, how versions are discovered and propagated, and an honest comparison against script-driven CI systems including where Concourse is the wrong choice.

Topics: Pipelines as configuration, not database state · Resources, resource types and versions · Jobs, builds and the scheduler · Containers as the unit of execution · Concourse compared with script-driven CI · Where Concourse is the wrong answer

  • Assignments: (1) Model an existing build as resources and jobs on paper before writing YAML; (2) Identify three pieces of hidden machine state in an existing CI job
  • Capstone: Produce a design note translating one real delivery process into the Concourse model
02Standing up Concourse and driving it with flyLive & Interactive5 hrs · 2 assignments · 1 capstone

Getting a working cluster and the command line that operates it. Quickstart with docker-compose, then the real architecture: web node, TSA worker registration, worker fleet and PostgreSQL. Then fly, which is the only interface that matters day to day.

Topics: Architecture: web, TSA, workers, PostgreSQL · Deployment options: binary, docker-compose, Helm, BOSH · fly login and target management · set-pipeline, unpause-pipeline, destroy-pipeline · validate-pipeline and format-pipeline · watch, trigger-job and check-resource · The web UI and what it is good for

  • Assignments: (1) Stand up a cluster and register a second worker; (2) Set, unpause and destroy a pipeline entirely from fly
  • Capstone: Deliver a documented cluster installation with two workers and a first working pipeline
03Writing pipelines — steps, plans and control flowLive & Interactive5 hrs · 2 assignments · 1 capstone

The pipeline language in depth. Build plans made of get, put and task steps, running work concurrently with in_parallel, grouping with do, tolerating failure with try, and the hooks that run on success, failure, error and abort.

Topics: get, put and task steps · Build plan structure and ordering · in_parallel, do and try · on_success, on_failure, on_error, on_abort and ensure · trigger: true and manual jobs · Job serial, serial_groups and max_in_flight · Groups for organising a large pipeline

  • Assignments: (1) Convert a linear shell build script into a build plan with real steps; (2) Add failure and abort hooks that notify correctly in both cases
  • Capstone: Build a multi-job pipeline that fans out testing in parallel and fans back in to a single package job
04Tasks as containersLive & Interactive5 hrs · 2 assignments · 1 capstone

The unit of work, treated properly. Task configuration files versus inline task specs, choosing an image resource, declaring inputs and outputs so files flow between steps, caches, params, and privileged execution when it is genuinely required.

Topics: Task config files vs inline task specs · platform and image_resource · Declared inputs and outputs · params and environment · Task caches · run: path and args · Privileged tasks and their cost · Sharing task files across pipelines

  • Assignments: (1) Extract an inline task into a versioned task file used by two pipelines; (2) Fix a task that silently depends on an undeclared input
  • Capstone: Build a task library that produces identical results on any worker in the fleet
05Resources in depth and the passed constraintLive & Interactive5 hrs · 2 assignments · 1 capstone

The feature that distinguishes Concourse. How version propagation works across the pipeline graph, why passed makes artifact promotion provable, and the resource types teams actually use — plus writing your own when nothing fits.

Topics: The passed constraint and version propagation · git, s3, semver, time and registry-image resources · github-release, slack-notification and pool resources · Locking with the pool resource · Custom resource types: check, in and out · Packaging a resource type as a container image · version: every vs latest · Resource checking, intervals and webhooks

  • Assignments: (1) Prove with passed that a deployed artifact is the tested one; (2) Write a minimal custom resource type and use it in a pipeline
  • Capstone: Build a promotion pipeline where a version physically cannot skip a stage
06Credentials, teams and access controlLive & Interactive5 hrs · 2 assignments · 1 capstone

Multi-tenancy and secrets, which in Concourse are the same conversation. Var interpolation from an external credential manager, team-scoped and pipeline-scoped secret paths, authentication providers and the four RBAC roles.

Topics: Var interpolation and why secrets never live in pipeline YAML · Vault as a credential manager · CredHub, AWS Secrets Manager and SSM · Kubernetes secrets backend · Team and pipeline credential path scoping · Teams and multi-tenancy · OAuth, OIDC, GitHub and LDAP authentication · Roles: owner, member, pipeline-operator, viewer

  • Assignments: (1) Move every credential out of a pipeline file into Vault; (2) Configure three teams with different roles on one cluster
  • Capstone: Deliver a multi-team cluster where no team can read another team's credentials
07Pipelines at scale — vars, across and self-configurationLive & Interactive5 hrs · 2 assignments · 1 capstone

Keeping a hundred pipelines maintainable. Var files and var_sources, the across step for matrix builds, set_pipeline so pipelines configure themselves from Git, and templating strategies including their failure modes.

Topics: Var files and -l on set-pipeline · var_sources and per-pipeline credentials · The across step for matrix execution · load_var for runtime values · The set_pipeline step and self-updating pipelines · Pipeline templating approaches and their trade-offs · Instanced pipelines · Archiving and pausing pipelines

  • Assignments: (1) Generate a matrix of builds with across instead of copy-pasted jobs; (2) Build a bootstrap pipeline that sets every other pipeline from Git
  • Capstone: Deliver an estate where adding a new service pipeline is a pull request, not a fly command
08Operating and debugging a clusterLive & Interactive5 hrs · 2 assignments · 1 capstone

Running Concourse in production. Debugging live inside a failing container with intercept and hijack, worker lifecycle and draining, garbage collection and disk pressure, build log retention, upgrades, metrics and the database that holds all the state.

Topics: fly intercept and hijack for live debugging · Worker states, draining, retiring and landing · Garbage collection and volume disk pressure · Build log retention policies · Upgrading web and worker nodes · PostgreSQL sizing, backup and migration · Prometheus metrics and alerting · Scaling web and worker tiers · Common failure signatures and their causes

  • Assignments: (1) Debug a genuinely failing build from inside its container; (2) Drain and replace a worker with no build interruption
  • Capstone: Produce an operations runbook covering upgrade, worker replacement, backup and restore

Need this mapped to your stack?

We rebuild the agenda around the tools you actually run.

Request a custom agenda
# hands-on

Labs and capstones your engineers actually build

LAB · CLUSTER

Cluster from nothing

Stand up web, worker and PostgreSQL, register a second worker through the TSA, and set your first pipeline entirely from the fly command line.

flyworkerspostgres
LAB · PIPELINE

Script to build plan

Take a monolithic shell build script and decompose it into resources, tasks with declared inputs and outputs, and a build plan that fans out in parallel.

tasksin_parallelbuild plan
LAB · PROVENANCE

Prove it with passed

Build a promotion pipeline where the passed constraint makes it structurally impossible for an untested version to reach the deploy job, then try to break it.

passedversionspromotion
LAB · RESOURCES

Write a custom resource type

Implement check, in and out for a resource Concourse has no type for, package it as a container image, and consume it from a pipeline.

resource typecheck/in/outimages
LAB · SECRETS

Empty the pipeline of secrets

Move every credential in a working pipeline into Vault with team-scoped paths, then verify a second team cannot read them.

vaultteamsrbac
CAPSTONE · OPERATIONS

Break it and bring it back

Debug a failing build from inside its container with intercept, then drain and replace a worker and restore the database without losing pipeline configuration.

interceptdrainrestore
# ecosystem

The tools Concourse sits next to

Git
Vault
CredHub
PostgreSQL
Docker
Kubernetes
Helm
AWS S3
Artifactory
Prometheus
Cloud Foundry
Slack

Who this is for

  • Platform engineers running or inheriting a Concourse estate
  • Release engineers who need provable artifact promotion
  • DevOps engineers migrating script-driven CI jobs into declarative pipelines
  • SREs responsible for CI cluster availability, upgrades and capacity
  • Cloud Foundry and Kubernetes platform teams whose tooling already assumes Concourse
  • Build engineers writing shared task and resource libraries for other teams

Pre-requisites

  • Comfortable on a Linux command line
  • Working knowledge of Docker images and container fundamentals
  • Familiarity with Git and with YAML
  • Understanding of how your application is built and released today
  • A Linux host or Kubernetes cluster to run web, worker and PostgreSQL for labs
# pricing

Straightforward pricing

Every plan includes 1 year of full LMS access — not just this course, the entire DevOpsSchool LMS: 20+ courses, 50+ tools, videos, quizzes, assignments and projects.

Self-paced video

₹833/mo

Billed yearly at ₹9,996

Enroll now

1-on-1 mentorship

₹99,999

Full program, private instructor

Enroll 1-on-1

Corporate / private batch

8–30 engineers · custom agenda · onsite or online · PO and GST invoicing

Get a custom quote

Refunds. If we cancel or postpone a cohort, you get a full refund within 15 days. There is no money-back guarantee otherwise.

Terms. Course material remains licensed to the attendee. Read the terms.

Your data. We don't share it with third parties. Privacy policy.

Every attendee gets a verifiable certificate

  • Issued per attendee on completion
  • Verifiable at devopsschool.com/certificates
  • Hard copy available on request
  • Corporate batches receive an attendance and assessment report
DevOpsSchool

Concourse Training

Certificate of completion

# feedback

What engineers say

4.4 / 5 from 26 reviews on Trustpilot.

★★★★☆
Helped to understand more on overall DevOps concepts.
Pankaj Malhotra · Trustpilot
★★★★★
Got good lab sessions which kept the new DevOps tool learnings to the point and it helped a lot in my career.
robin son · Trustpilot
★★★★★
My experience with the AIOps training was positive. The course covered important topics in a structured way, and Rajesh Kumar explained the concepts patiently. I found the practical aspects particularly helpful because they made the technical content easier to understand.
AARTI KUMARI · Trustpilot
★★★★★
I was looking to improve my understanding of AIOps, and this training helped me achieve that goal. Rajesh Kumar explained the subject in a structured and practical manner. The sessions on different AIOps concepts were informative.
Sonali Tiwari · Trustpilot
★★★★★
I recently did a SRE Session with Rajesh Kumar from DevOps School and the session was great. Right from 1st day till day 15, we had a very interactive session. Rajesh clarified our doubts and the tool demos were excellent without any hiccups. He simplified the concepts while sticking to the content with a fine balance between theory and practice. Am convinced he is one of the best trainers for SRE & DevOps concepts.
chandrasekaran j · Trustpilot
★★★★★
The Rundeck developer session was excellent and highly engaging. I appreciated how well the session was structured, with the theoretical concepts explained clearly and in simple terms. What stood out most to me was the demo — it was both informative and enjoyable. I especially liked how Rajesh walked us through not only the happy path but also the sad path, showcasing common issues and sharing practical troubleshooting tips.
Raimy Roy · Trustpilot
# comparison

Why a named practitioner beats a marketplace listing

What mattersYouTube + blogsGeneric online courseFreelance marketplaceDevOpsSchool
Named practitionerNoRarelyVaries per bookingYes — same trainer each time
Production experienceUnknownUnknownUnverified20 years, named employers
Custom agendaNoNoSometimesBuilt from your stack
Onsite deliveryNoNoSometimesYes
Lab environmentNoneSandbox that expiresVariesYour own cloud — skill goes with you
AssessmentNoneQuizRarelyAssignments + capstone per module
Per-attendee certificatesNoSometimesRarelyYes
Corporate invoicingNoLimitedVariesPO and GST
Post-training supportNoneForum, time-limitedNoneLifetime forum access
# questions

Frequently asked

Our team keeps writing Concourse pipelines that fight the tool. Can you fix that?
That is the core of module 1 and module 4. Most of the pain comes from treating tasks as shell scripts on a shared machine rather than containers with declared inputs and outputs. We rewrite one of your real pipelines idiomatically during the batch.
Do you cover the passed constraint properly?
Yes, module 5 is largely about it. It is the feature that distinguishes Concourse, and we build a pipeline where an untested version physically cannot reach the deploy job, then attempt to break it.
Can you cover writing custom resource types?
Yes. Module 5 covers the check, in and out contract, packaging the resource as a container image, and — just as importantly — when not to write one because an existing type already fits.
We need secrets out of our pipeline files. Which backends do you cover?
Vault and CredHub in depth, plus AWS Secrets Manager, SSM Parameter Store and the Kubernetes secrets backend, including team and pipeline path scoping so teams cannot read each other's credentials.
Do you cover operating the cluster, or only writing pipelines?
Both. Module 8 covers worker draining and replacement, garbage collection, disk pressure, upgrades, metrics and PostgreSQL backup and restore, with a live worker replacement during the lab.
How do we manage a hundred pipelines without copy-paste?
Module 7. The across step for matrix builds, var files and var_sources, and the set_pipeline step so a bootstrap pipeline configures every other pipeline from Git — adding a service becomes a pull request.
How long does a private Concourse batch take?
Three to four days. Three covers the model, pipeline authoring, resources and credentials; the fourth adds scale patterns, custom resource types and cluster operations.
Can the agenda be customised for our stack?
Yes — the normal case for a private batch. We start with a discovery call and rebuild the agenda around your resource types, credential manager, deployment targets and cluster topology.
What lab environment is needed?
A Linux host or a small Kubernetes cluster capable of running web, worker and PostgreSQL. Free-tier cloud instances or local VMs are sufficient, and attendees keep what they build.
Do you deliver onsite?
Yes. Private batches run onsite at your premises, live online, or hybrid, scheduled around your release calendar.
What size are batches?
Private corporate batches run 8 to 30 engineers. Public Live & Interactive cohorts are capped at 10 so everyone gets time with the trainer.
What is your refund position?
If we cancel or postpone a cohort, you receive a full refund within 15 days. There is no general money-back guarantee, and GST and gateway fees are not refunded.

Still deciding?

Tell us the team, the stack and the timeline. You'll get a straight answer, not a sales sequence.

Talk to an advisor
# ready when you are

Book a Concourse trainer — or ask a question first.

  • No spam, no drip sequence
  • Syllabus in 60 seconds
  • A human reply within one business day

Prefer to call or email?

More ways to reach us on the contact page.

Talk to an advisorRequest a quote