Containerised application with Compose
Deliverable: A multi-service application running under Docker Compose with persistent volumes, a documented Dockerfile and a written note on how image size was reduced.
Course
DevOps
The toolchain taught around the goal it serves — shipping small changes safely and often — rather than as a list of products to name on a CV.
- Duration: 6 months
- Classroom · Online live
- Level: intermediate
What you will be able to do
- Operate confidently on Linux and automate routine work with shell scripts
- Containerise an application and explain what the image actually contains
- Deploy and troubleshoot workloads on Kubernetes, including failing pods
- Build a CI/CD pipeline that blocks a broken merge and deploys automatically
- Provision infrastructure reproducibly with Terraform rather than by clicking
- Set up monitoring and alerting that distinguishes a real incident from noise
Who this course is for
- Graduates in engineering, computer applications or IT
- System administrators and support engineers moving into automation
- Developers who want to own how their code reaches production
- Comfort with the Linux command line is genuinely required here
Syllabus
7 modules · 6 months
Module 1. Linux and scripting foundations
- Filesystem, permissions, processes and services
- Package management and systemd units
- Reading logs and diagnosing a failing service
- Bash scripting for real automation
- SSH, keys and secure remote access
Module 2. Version control and collaboration
- Git internals enough to recover from mistakes
- Branching strategies and their trade-offs
- Pull requests, review and merge conflict resolution
- Tagging, releases and semantic versioning
Module 3. Containers
- What a container actually is, and what it is not
- Writing Dockerfiles and understanding image layers
- Image size, caching and build performance
- Volumes, networks and Docker Compose
- Registries, tagging strategy and image scanning
Module 4. Kubernetes
- Cluster architecture, nodes and the control plane
- Pods, ReplicaSets, Deployments and Services
- ConfigMaps, Secrets and configuration management
- Ingress and routing external traffic
- Health probes, resource limits and why pods get evicted
- Debugging a CrashLoopBackOff methodically
- Helm charts and templated deployments
Module 5. Continuous integration and delivery
- What CI is actually for, beyond running tests
- Pipeline design with GitHub Actions and Jenkins
- Build artefacts, caching and pipeline speed
- Deployment strategies — rolling, blue-green and canary
- Rollback as a first-class capability
- Secrets in pipelines without leaking them
Module 6. Infrastructure as code
- Why clicking in a console does not scale
- Terraform providers, resources and state
- Modules, variables and reusable infrastructure
- Drift detection and importing existing resources
- Ansible for configuration management
Module 7. Monitoring and operations
- Metrics, logs and traces, and what each answers
- Prometheus, exporters and PromQL basics
- Grafana dashboards that support a decision
- Alerting that does not train people to ignore it
- Incident response and blameless postmortems
Tools and technologies you will use
- Linux
- Bash
- Git and GitHub
- Docker
- Kubernetes
- Jenkins and GitHub Actions
- Terraform
- Ansible
- Prometheus and Grafana
- AWS
Projects you will build
CI/CD pipeline
Deliverable: A pipeline that runs tests, builds an image, pushes to a registry and deploys on merge, with a demonstrated rollback and secrets handled without appearing in logs.
Kubernetes deployment
Deliverable: An application deployed to Kubernetes with health probes, resource limits, ConfigMaps and Ingress, plus a written diagnosis of a deliberately broken pod.
Infrastructure as code build
Deliverable: A Terraform configuration provisioning a complete environment from nothing, with modules, remote state and a documented plan output showing what it would change.
Where this course can take you
- DevOps Engineer
- Site Reliability Engineer
- Cloud Engineer
- Build and Release Engineer
- Platform Engineer
Duration, modes and fees
- Duration
- 6 months
- Delivery modes
- Classroom · Online live
- Fees
- Share your details for the current fee
- Fees vary by batch and delivery mode. Share your details and an advisor will confirm the current fee.
Placement assistance
Every student gets placement assistance — that is what 100% placement assistance means. It is support for all, not a job for all. We do not promise a specific salary, a specific number of interviews, or placement at any named company, and you should be wary of anyone who does.
What is included
- A place in the monthly placement drive, held every third Saturday
- The readiness programme every second Saturday — mock interviews and preparation
- CV review against the specific roles you are targeting
- Portfolio review, so your project work is presented the way a reviewer will read it
- Access to the vacancy pool employers send directly to the Samyak network
- Guidance on which roles realistically fit your background and which do not
- A place in the next drive, with coaching, if you are not selected in this one
What is not included
- Any guarantee of a job, an interview, or a particular salary
- Placement at a named or partner company
- Applying to jobs on your behalf
- Support before you have completed the course and its project work
- Visa, relocation or overseas placement assistance
DevOps is a goal, not a toolchain
The word gets used to mean a list of products. Learn Docker, learn Kubernetes, learn Jenkins, add them to your CV.
That framing produces people who can install things and cannot explain why. The actual goal is narrower and more useful to state: make it possible to ship a small change safely, quickly, and often, and to recover when it goes wrong.
Every tool in this course exists because it serves that goal. Containers make environments reproducible. Pipelines make verification automatic. Infrastructure as code makes environments rebuildable. Monitoring makes failure visible before a customer reports it. Taught in that order, the toolchain has a logic; taught as a product list, it does not.
Failure is the curriculum
You will spend a meaningful share of this course fixing things that are broken on purpose.
A pod in CrashLoopBackOff. A pipeline that passes locally and fails in CI. A Terraform plan that wants to destroy something it should not. A service that runs until it hits its memory limit.
This is deliberate, and it is the difference between the course and a documentation tutorial. In a real job nobody hands you a working system and asks you to describe it — they hand you a broken one at an inconvenient hour. The skill is methodical narrowing, and it only develops by doing it.
Being honest about the fresher question
DevOps is not an easy first job, and we would rather say so.
The work assumes you know what you are deploying and what breaking it costs, and that knowledge normally comes from having built or supported software. Job descriptions reflect this — most ask for prior experience.
The realistic path for someone starting out is to enter through development, support or QA, be the person on that team who automates the tedious parts, and move across within a year or two. This course prepares you for that move properly. What it will not do is guarantee a DevOps title straight out of it, and you should be wary of anyone promising otherwise.
Questions
DevOps — frequently asked questions
Can I get a DevOps job as a fresher?
It is harder than for development roles, and worth knowing before you start. DevOps work assumes you understand what is being deployed and what breaking it costs, which usually comes from a year or two in development or systems administration. Many people enter through a support, QA or junior developer role and move across within eighteen months.
Do I need to know a programming language for DevOps?
Yes, at least one, well enough to read the applications you are deploying and to write real automation. Python is the common choice and Bash is non-negotiable. You are not building features, but a DevOps engineer who cannot read a stack trace cannot diagnose a deployment failure.
Is Kubernetes necessary, or is Docker enough?
Docker alone is enough for a great many organisations, and Kubernetes adds substantial operational complexity that smaller teams often do not need. That said, Kubernetes appears in a large share of DevOps job descriptions in India, so it is worth learning even where you would not choose it yourself.
How is this different from your AWS course?
The AWS course covers cloud infrastructure — networking, compute, storage, identity and architecture on one provider. This covers the delivery pipeline that sits on top, and is largely provider-agnostic. They complement each other, and doing AWS first makes this course noticeably easier.
Why does the course spend so long on Linux?
Because almost every DevOps failure is diagnosed on a Linux box at some point, and a candidate who cannot read a systemd log or trace a permission problem stalls in interviews. It is the least glamorous module and the one that most reliably separates people who can operate from people who can only configure.
Enquire about DevOps
Three details is all we need. A course advisor will call you back.
Related courses
- AWS Cloud Computing
AWS taught by building and breaking infrastructure rather than by memorising service names, ending with an architecture you have deployed, secured, costed and can defend.
- Python Programming
Python taught as a working tool rather than a syntax tour — you finish able to read unfamiliar code, automate real tasks, call APIs and write tests that catch your own mistakes.
- Full Stack Development
Front end, back end, databases and deployment taught as one connected system, ending with applications you have shipped to a public URL and can walk an interviewer through.
Next step
Talk to a course advisor
Tell us what you want to learn and we will help you pick the right course, batch and mode.