Newton Institute of Technology Logo
Newton Institute of Technology Building Your Dream Career

What Is DevOps? Beginner Guide With Examples & CI/CD

ICT Explained · Beginner’s Guide

What Is DevOps? A Beginner-Friendly Explanation

Understand how teams plan, test, release and monitor software, then build your first automated test using Python and GitHub Actions.

8 lifecycle stages3 real-life examples6-test CI exercise
devops-flow.txt
# One small code change plan → code → test          ↓ release → deploy          ↓ monitor → improve

Quick answer

What is DevOps in simple terms?

DevOps combines software development (Dev) and IT operations (Ops) through teamwork, automation and feedback. It helps the people who create software work with those who deploy, maintain and monitor it. The goal is to deliver useful changes reliably and learn from the results. DevOps is an approach to working—not a programming language or a single tool. [1]

  • Plan
  • Build
  • Test
  • Operate
  • Improve
DifficultyBeginner
Practical toolsPython + GitHub
First goal6 automated tests

Imagine a school adds a button for downloading examination results. Someone writes the code, someone tests it, and someone makes sure the site continues working after the update. DevOps connects those responsibilities so the change can move safely from an idea to a working feature.

What does DevOps mean?

The name combines development and operations. Developers create and improve software; operations specialists help keep applications and the systems supporting them running.

Development (Dev)

Write code, fix bugs, create new features and test application behaviour.

Operations (Ops)

Configure systems, monitor applications, manage changes and restore services after failures.

DevOps together

Share responsibility for a useful change—from planning through deployment, operation and improvement.

A developer may make a form work perfectly on a laptop, yet the form could fail on a busy server. An operations engineer may configure a dependable server, but cannot fix incorrect application logic merely through server settings. Collaboration helps the team account for both.

DevOps is an approach, not a product

Git, GitHub Actions, Docker and other tools can support DevOps, but no single tool creates good teamwork or a reliable delivery process. [2]

Why do organizations use DevOps?

Consider a school opening its online registration portal. Ten people successfully test the application, but hundreds of applicants arrive on registration day and some submissions fail. The cause could be overloaded infrastructure, a faulty configuration or a software defect.

A coordinated team prepares for expected traffic, tests critical functions, checks monitoring and defines recovery steps before registration begins. If something goes wrong, developers and operations staff examine evidence together.

  • Collaboration: people understand one another’s responsibilities and solve problems together.
  • Automation: repeatable checks are performed consistently.
  • Early feedback: teams discover some errors sooner.
  • Reliable delivery: releases follow documented steps.
  • Continuous improvement: incidents and user feedback guide the next change.

DevOps does not eliminate failures; it helps teams manage change and respond effectively when a failure occurs. [1][2]

How does DevOps work? The eight-stage lifecycle

A school wants students to download PDF copies of their examination results. That sounds simple, but the new feature must protect private information and avoid breaking the existing site. Follow the change through a commonly taught eight-stage lifecycle. [3]

StageMeaningSchool portal example
1. PlanAgree on the requirementsSpecify PDF download rules
2. CodeCreate and record changesWrite and commit the PDF function
3. BuildPrepare software to runPackage the updated application
4. TestCheck expected behaviourVerify marks, access and downloads
5. ReleasePrepare an approved versionReview the tested update
6. DeployPut the version into an environmentUpdate the school server
7. OperateKeep the application availableMaintain the live portal
8. MonitorObserve errors and performanceDetect failed downloads

Plan: define success

The team agrees that each student can download only their own results, the marks are correct, the feature works on a phone and the original results page keeps working. These testable conditions are called acceptance criteria.

Code: create the change

A developer builds the download function and records the changes using Git, a version-control system. The change history helps others review what was modified.

Build: prepare the application

The system compiles or packages the software as necessary. A successful build shows the preparation step completed; it does not prove that all functions work correctly.

Test: check the behaviour

Test situationExpected result
Student downloads own resultsCorrect PDF
Student requests another person’s resultsAccess denied
Student uses a phoneDownload works
Student opens original results pageExisting function still works

Automated checks can verify many conditions. Layout and usability may need human inspection.

Release: prepare an approved version

The team reviews the changes, documents them and prepares a version for release. A version may be ready without being installed in the live environment.

Deploy: make a version available

Development is where programmers work; staging is where changes are checked; production is where real users access the service. Deploying code and switching a feature on for users can be separate actions.

Operate: support the running system

The team manages configuration, backups, access and everyday technical operations.

Monitor: learn from the result

If downloads fail after release, engineers inspect logs, error reports and recent changes, then correct the fault and improve the checks. A log is a record of events from a system.

Remember the cycle

Plan → Code → Build → Test → Release → Deploy → Operate → Monitor → Improve and repeat. In practice, security, testing and collaboration happen across the whole lifecycle.

What is CI/CD in DevOps?

CI means Continuous Integration. CD can mean Continuous Delivery or Continuous Deployment. Although related, they are different practices. [4]

Continuous integration

Developers regularly combine code changes and use automated builds or tests to catch errors.

Continuous delivery

Tested changes are kept ready for a reliable release; a human production approval may remain.

Continuous deployment

Eligible changes are automatically deployed after the required checks and release conditions pass.

For example, a new school-portal feature might accidentally break the login page. An automated login test could flag the problem when developers combine their changes.

A green test is not a release approval

A CI workflow can report the result of its checks without preventing someone from merging or deploying code. Enforcing a required check may also need branch protection, code review or release rules. [5]

Three practical DevOps examples

These fictional learning scenarios illustrate three different responsibilities: updating business software, preventing a bug and recovering from a failure.

Water-production system

An update must deduct bottles, caps and labels correctly and reject insufficient stock.

Online stationery shop

Automated tests catch an incorrect calculation before a change is approved.

Delivery-tracking website

Monitoring and troubleshooting help restore service after a faulty deployment.

Example 1: A water-production system

A small facility records 500 bottle caps in stock. A production operation uses 200, leaving 300 caps. The update should reject a request to use more caps than are available and should not deduct the same recorded production operation twice.

Starting stockOperationCorrect outcome
500 capsUse 200300 remain
500 capsUse 5000 remain
500 capsUse 600Reject: insufficient stock
500 capsRepeat an already processed operationDo not double-deduct

Developers test the stock rules. Production staff then confirm the workflow remains usable after deployment, and the technical team investigates discrepancies reported during operation.

Example 2: A shop calculates the wrong total

Two exercise books cost KSh 50 each. The correct total is 2 × KSh 50 = KSh 100. A programmer accidentally changes multiplication to addition, producing 50 + 2 = 52. A test expecting 100 fails. The team fixes the error, retests and then reviews the change.

Example 3: A delivery website fails

After a deployment, customers receive errors when tracking parcels. Monitoring shows an unusual increase in failed requests. Engineers inspect logs and recent changes, identify an incorrect configuration, restore service, confirm recovery and improve future checks.

Why rollback needs care

A rollback means returning to an earlier version. If a deployment also changed stored data or database structures, reversing application code alone may not safely restore the system.

Which tools do DevOps teams use?

Choose tools based on the task. A beginner does not need to master every technology in this table.

ToolMain purposePlain-language meaning
GitVersion controlTracks project changes
GitHubCollaborationHosts projects and code review
GitHub ActionsAutomationRuns checks after repository events
DockerContainersPackages applications with a consistent environment
TerraformInfrastructure as CodeDescribes infrastructure in configuration files
PrometheusMonitoringCollects operational measurements
GrafanaVisualizationDisplays measurements on dashboards

GitHub Actions and Docker are examples of tools that support testing and consistent application environments. [6][7]

Hands-on project: automate your first software tests

In this activity you will create a tiny Python price calculator, write six automated tests, and watch GitHub Actions detect a deliberately broken calculation. The exercise demonstrates continuous integration; it does not deploy a live application. On a phone, swipe within wide code windows and tables to see the rest of each line or column.

You will need

A GitHub account, an internet connection and a web browser. You can complete the example entirely on GitHub without installing Python locally. Work only with fictional data; do not publish private records or passwords. GitHub accounts have a minimum age of 13 and any higher local legal minimum; learners who are not eligible can use a suitable teacher-supervised alternative. [12]

Create your repository

At github.com, create a repository named devops-beginner-shop. Choose Public only if you are comfortable sharing practice files. Your project will contain calculator.py, test_calculator.py and .github/workflows/tests.yml.

Write the calculator

Choose Add file → Create new file, name it calculator.py, enter the code and commit it.

calculator.py
def total_cost(price, quantity):     if type(price) is not int:         raise TypeError("Price must be whole")       if type(quantity) is not int:         raise TypeError("Quantity must be whole")       if price < 0 or quantity < 0:         raise ValueError("Values cannot be negative")       return price * quantity

The function multiplies a whole-number item price by the quantity, rejects other input types, and rejects negative values. Calling total_cost(50, 2) should produce 100. This is a teaching calculator, not a full financial application.

Create six automated tests

Create test_calculator.py, paste the test code below and commit it. Python’s built-in unittest framework compares actual results with expected results. [8]

test_calculator.py
import unittest from calculator import total_cost     class ShopCalculatorTests(unittest.TestCase):     def test_two_bottles(self):         self.assertEqual(total_cost(50, 2), 100)       def test_zero_quantity(self):         self.assertEqual(total_cost(50, 0), 0)       def test_zero_price(self):         self.assertEqual(total_cost(0, 4), 0)       def test_negative_price(self):         with self.assertRaises(ValueError):             total_cost(-50, 2)       def test_negative_quantity(self):         with self.assertRaises(ValueError):             total_cost(50, -1)       def test_decimal_quantity(self):         with self.assertRaises(TypeError):             total_cost(50, 2.5)     if __name__ == "__main__":     unittest.main()
CaseInputExpected
Ordinary purchase50 × 2100
Zero quantity50 × 00
Free items0 × 40
Negative price-50 and 2Reject
Negative quantity50 and -1Reject
Decimal quantity50 and 2.5Reject

Create the automated workflow

Create the file at the exact path .github/workflows/tests.yml, paste this workflow and commit it. GitHub Actions uses workflow files in this directory. [6]

tests.yml
name: Test Shop Calculator   "on": [push, pull_request]   permissions:   contents: read   jobs:   test:     runs-on: ubuntu-latest       steps:       – name: Get project files         uses: actions/checkout@v7         with:           persist-credentials: false         – name: Set up Python         uses: actions/setup-python@v7         with:           python-version: '3.12'         – name: Run tests and check discovery         run: |           python -m unittest discover -v           python – <<'PY'           import unittest           suite = unittest.defaultTestLoader.discover('.')           count = suite.countTestCases()           assert count >= 6, f'Expected 6; got {count}'           PY

The workflow checks out your repository, sets up Python 3.12, runs the tests, and then checks that at least six tests were discovered. GitHub’s current checkout and Python actions document these major-version tags. [9][11]

Run and inspect the result

Open Actions → Test Shop Calculator → latest run → test. If everything is correct, you should see:

expected-output.txt
Ran 6 tests   OK

A green result means the configured checks passed for that run. Verify the log actually says Ran 6 tests, not just that the job icon is green.

Deliberately break the calculation

In calculator.py replace return price * quantity with return price + quantity and commit the change. Two bottles at KSh 50 each now return 52 instead of 100. The workflow should fail, including an error like AssertionError: 52 != 100. Three tests should fail; the three validation tests should still pass.

Fix it and confirm recovery

Restore return price * quantity and commit again. The tests should return to six passing checks. You have demonstrated change → test → detect → correct → retest.

Check what happens when tests are missing

If two test methods are accidentally removed, four remaining tests may pass. The added test-count check should make the job fail because fewer than six tests were discovered. A minimum count is a simple safeguard, not a substitute for reviewing which requirements are tested.

ProblemWhat to inspect
No workflow appearsConfirm the path .github/workflows/tests.yml
Workflow will not startCheck Actions permissions and whether a trigger occurred
Python import errorCheck calculator.py spelling and location
No tests foundCheck test_calculator.py filename
Unexpected totalCompare actual result with expected result
YAML errorCheck indentation and the workflow file
Too few testsRestore missing test methods

Try one extra challenge

Add a seventh test checking three items priced at KSh 40 each. The correct total is KSh 120. Change one thing, rerun the tests and read the result.

How do teams measure DevOps improvement?

Installing many tools does not prove a team is improving. A more useful question is whether software changes reach users reliably and whether failures can be corrected effectively.

DORA describes five software-delivery performance metrics that help teams examine throughput and instability. [10]

MetricWhat it asks
Change lead timeHow long from a code commit to production?
Deployment frequencyHow often do we deploy?
Failed deployment recovery timeHow quickly can we recover after a failed deployment?
Change fail rateWhat proportion of deployments need immediate corrective action?
Deployment rework rateWhat share of deployments respond unexpectedly to production incidents?

For a beginner, the lesson is simple: shipping faster is not useful if the software repeatedly fails. Teams should improve delivery speed and dependability together.

DevOps vs software development vs cloud computing

The areas are related, but each has a different emphasis.

FieldMain focusExample
Software developmentCreating and maintaining applicationsBuild a school portal
Cloud computingProviding computing resources over a networkHost an application
Cloud engineeringDesigning and operating cloud infrastructureConfigure cloud servers
DevOpsImproving software delivery and operationsAutomate tests and monitor releases

One person may perform several of these tasks, especially in a small organization. DevOps can also work on privately hosted or on-premises servers; public cloud hosting is not required. To learn more about application code, read NIT’s backend developer guide.

Can a complete beginner learn DevOps?

Yes. Start with basic computing and a small application, then add automation and operations knowledge as your understanding grows.

StageLearnPractical goal
1. ComputingFiles, operating systems, networkingExplain where an application runs
2. ProgrammingPython, functions, errorsWrite a small program
3. Version controlGit, commits, repositoriesRecord and explain a change
4. Automated testsunittest and GitHub ActionsGet a passing and failing CI run
5. DeploymentServers, environments, containersRun an application consistently
6. OperationsLogs, monitoring, recoveryDiagnose and correct a simulated failure

Programming and scripting are useful for many DevOps roles. Learn a concept, practise it and create evidence that you can explain—not merely a list of tool names.

Five DevOps mistakes beginners should avoid

  • Thinking DevOps is only about tools. Communication and shared responsibility matter as well.
  • Automating a process you do not understand. Define the expected outcome before automating.
  • Treating deployment as the finish line. Applications need monitoring and support afterward.
  • Assuming passing tests mean perfection. A test checks only the behaviour it covers.
  • Trying to learn every tool immediately. Begin with one small application and a useful automated check.

Frequently asked questions

What is DevOps in one sentence?

DevOps connects software development and operations through teamwork, automation and feedback to improve software delivery and reliability.

Is DevOps a programming language?

No. It is an approach to developing, delivering and operating software. Programming and scripting often support the work.

What is a simple example of DevOps?

A team adds a website feature, runs automated tests, deploys an approved version, monitors the result and fixes any problems.

How is DevOps different from CI/CD?

DevOps is the broader approach. CI/CD describes specific practices for integrating, testing, preparing and deploying changes.

Is DevOps the same as Agile?

No. Agile emphasizes iterative development and responding to changing needs. DevOps connects development with delivery and operations. Teams often use both.

Can DevOps work without cloud computing?

Yes. The practices apply to private servers, on-premises systems, cloud environments and combinations of them.

What is DevSecOps?

DevSecOps emphasizes considering security continuously throughout development, delivery and operations.

Do DevOps engineers need to code?

Scripting and programming skills are valuable for many automation and infrastructure tasks. The exact role varies by employer.

Can secondary-school learners start?

Yes. Begin with computing fundamentals, Python, Git and small automated tests, then progress gradually.

What should you remember about DevOps?

DevOps connects writing software with the work needed to test, release, operate and improve it. That includes collaboration, repeatable processes and useful feedback from real applications.

You have followed a school portal through the eight-stage lifecycle, explored stock and price-calculation checks, and seen how engineers can recover from a failed deployment. You also have a reproducible beginner CI project.

Your next practical step

Create the calculator, run six tests, introduce the deliberate error and correct it. Understanding what failed—and proving the fix—is a strong start.

Sources and references

  1. Microsoft Learn — What Is DevOps?.
  2. Amazon Web Services — What Is DevOps?.
  3. IBM — What Is the DevOps Lifecycle?.
  4. Amazon Web Services — What Is CI/CD?.
  5. GitHub Docs — About Protected Branches.
  6. GitHub Docs — Workflows.
  7. Docker Docs — Docker Overview.
  8. Python Documentation — unittest.
  9. Official GitHub Actions — checkout and setup-python.
  10. DORA — Software Delivery Performance Metrics.
  11. GitHub — actions/checkout.
  12. GitHub Terms of Service.

Technical documentation reviewed: 10 November 2026. Sources are linked near the claims they support.

Continue learning at NIT

Learn DevOps and practical ICT skills

Explore software automation, testing, deployment and operations through Newton Institute of Technology’s ICT training pathways in Migori, Kenya. Our admissions team can explain current entry requirements and available intakes.

Learning focusDevOps

Understand continuous integration, delivery and automation.

Supporting skillsPython + Git

Build a practical computing foundation.

Next stepAsk admissions

Explore suitable programmes and current schedules.

Newton Institute of Technology · Migori Town, Kenya · +254 713 584 858 · info@niteducation.com