DevOps Fundamentals

Topics:

Rahulbobadi · 2026-03-13 08:41 · 0 claps · 12.8 min read

#devops-fundamentals

Open on Medium ↗

Wiki topics: ☁️ · DevOps & Cloud

DevOps Fundamentals

Topics:

DevOps principles and life cycle

DevOps Philosophy and Key Principles

DevOps means developers, operations teams, and quality testers working together as one team to build, test, and run software.

Instead of working separately, everyone collaborates from the start to the end of the software process. This helps companies release software faster, fix problems quickly, and improve quality.

The three foundational principles of DevOps can be summed up as:

Collaboration: Building a culture where development, operations, and quality assurance work seamlessly together.
Automation: Automating repetitive processes, especially in testing, deployment, and infrastructure, to reduce human error and accelerate workflows.
Continuous Improvement: Leveraging a feedback loop to learn from each iteration, improving efficiency, reliability, and resilience in the process.

Modern Strategies in DevOps: Shift-Left Principles

The shift-left approach means checking for bugs, security problems, and quality issues earlier in the development process, instead of waiting until the end.

In older methods, testing and security were done later, which often caused delays when problems were found. Shift-left solves this by starting testing and security checks from the beginning of development.

Teams also use automated tools in CI/CD pipelines to automatically test code and scan for vulnerabilities while the software is being built.

DevOps lifecycle

Plan

Define Requirements: Development, operations, and QA/QE teams collaborate to outline application requirements, infrastructure needs, and quality standards.
Set Objectives: Teams define goals, timelines, and key metrics for performance, security, and scalability.
Backlog Creation and Prioritization: Features and tasks are organized in a backlog, prioritizing work to align with project milestones and business needs.

Develop

Code Development: Developers write code, building the core functionality of the application in small, manageable chunks.
Version Control: All code changes are tracked and managed in a version control system (e.g., Git) to ensure code integrity and facilitate collaboration.
Automated Code Reviews and Testing: Static code analysis tools are used to catch code issues early. Unit tests are written and executed to validate individual components.

Build (Continuous Integration)

Automated Builds: Code changes are automatically built into executable files to verify compatibility and stability.
Run Automated Tests: Unit and integration tests are run during the build to catch any integration issues as soon as possible.
Continuous Feedback: Any build or test failures provide immediate feedback to the development team, enabling fast fixes and minimizing delays.

Test (Continuous Testing)

Integration and System Testing: Testing is expanded to cover larger parts of the application, ensuring that all components work together as expected.
End-to-End Testing: Tests that simulate real-world usage are run to confirm that the application meets all functional and non-functional requirements.
Shift-Left Security: Automated vulnerability scans are integrated into testing to detect and address security risks early in the process.

Release (Continuous Delivery)

Package and Versioning: Code is packaged for deployment, and a new version is created with unique identifiers.
Deploy to Staging Environment: The code is deployed to a staging or pre-production environment for final validation.
Manual Approvals (if required): In some workflows, human approval may be required before releasing to production, adding an extra layer of quality assurance.

Deploy (Continuous Deployment)

Production Deployment: The application is deployed to the live production environment, making it accessible to end users.
Automated Rollback (if necessary): Deployment tools often have rollback capabilities to revert changes quickly if issues arise in production.
Feature Flags: New features can be toggled on or off, allowing teams to deploy code safely without impacting the user experience.

Operate (Continuous Monitoring and Logging)

Monitor Performance and Availability: Real-time monitoring tools (e.g., Prometheus, Grafana) track the application’s health and performance, ensuring it meets SLAs.
Log Analysis: Logs provide detailed insights into system behavior, errors, and usage patterns, enabling quick troubleshooting and continuous improvement.
Alerting: Automated alerts notify the team of any anomalies or performance degradation, allowing for rapid response to incidents.

Feedback (Continuous Improvement)

Collect User and System Feedback: Feedback loops from users, as well as system metrics, are gathered and analyzed to understand application performance and user satisfaction.
Post-Mortem Analysis: After incidents or significant releases, a post-mortem is conducted to assess what went well and where improvements can be made.
Iterate and Improve: Insights gained from feedback are incorporated into the next planning phase, promoting a culture of continuous learning and improvement.

DevOps Best Practices

To adopt DevOps effectively, here are some proven best practices:

Continuous Testing and QA: Emphasize continuous testing, where QA/QE teams work alongside development and operations teams. Automated testing integrated into CI/CD pipelines, with tools like Jenkins or GitHub Actions, ensures quality remains a priority at each stage of development.
Continuous Integration (CI): Frequent integration of code changes to a shared repository ensures early detection of integration issues and improves collaboration.
Continuous Delivery (CD): Automating the release process so code can be deployed to production reliably and quickly, enabling rapid delivery of new features or updates.
Infrastructure as Code (IaC): Treating infrastructure configurations as code allows teams to version-control, automate, and scale infrastructure efficiently.
Monitoring and Logging: Implementing robust monitoring and logging helps teams gain real-time insights into system performance, quickly detect issues, and optimize accordingly.
Build a Collaborative Culture: Encourage open communication and shared ownership among teams. DevOps isn’t just about tools; it’s about people working together.
Foster a Quality-First Culture: Beyond collaboration, make quality everyone’s responsibility. Embedding QE and QA in each phase reinforces the DevOps principle that quality isn’t an afterthought — it’s an integral part of every step.
Automate Everything: From testing and deployments to infrastructure, automation is critical for scaling and reducing manual errors.
Implement Shift-Left Security: Start thinking about security early and integrate security measures into your CI/CD pipeline.
Leverage AI and Analytics: AI can be a powerful ally in your DevOps toolkit, helping identify patterns, detect anomalies, and automate decision-making processes in your pipelines.

DevOps culture (CAMS model)

Culture, Automation, Measurement, and Sharing.

Culture: Teams like developers and operations work together, share responsibilities, and communicate better instead of working separately.
Automation: Automating tasks (like testing and deployment) saves time and improves efficiency.
Measurement: Teams track important metrics (performance, failures, recovery time, etc.) to see if improvements are happening.
Sharing: Knowledge, feedback, and information are shared openly so the whole team can learn and improve.

Understanding CI/CD workflows

Continuous Integration (CI)

Developers frequently merge code into a shared repository, and an automated system builds and tests the code.

Goal:

Detect bugs early
Maintain code quality
Avoid integration conflicts

Continuous Delivery (CD)

After CI succeeds, the application is always ready to be deployed, but deployment to production may require manual approval.

Continuous Deployment

Every successful change automatically goes to production without human approval.

Developer │ ▼ Git Repository │ ▼ CI Pipeline Trigger │ ├── Build ├── Unit Tests ├── Static Code Analysis │ ▼ Artifact Repository │ ▼ Deployment Pipeline │ ├── Integration Tests ├── Security Scans │ ▼ Production Deployment │ ▼ Monitoring & Feedback

Monitoring & Feedback is a critical stage of the DevOps lifecycle. This stage is about observability, reliability engineering, incident response, and continuous improvement.

Monitoring happens after deployment.

Typical lifecycle:

Plan → Code → Build → Test → Deploy → Operate → Monitor → Improve

Monitoring feeds information back to development teams, enabling continuous improvement.

Types of Monitoring

There are several types of monitoring used in DevOps.

Infrastructure Monitoring

Tracks system resources.

Examples:

CPU usage
Memory utilization
Disk I/O
Network traffic

Example metrics:

CPU Usage = 65%
Memory Usage = 70%
Disk I/O = 150 MB/s

Tools:

Prometheus
Datadog
Nagios

Application Monitoring

Monitors application performance.

Metrics include:

Response time
Error rate
Request throughput

Example:

Average API response time: 200ms
Error rate: 0.5%
Requests per second: 2000

Tools:

New Relic
AppDynamics
Prometheus + Grafana

Log Monitoring

Applications produce logs.

Example logs:

INFO User login success
ERROR Database connection failed
WARNING API latency high

Log aggregation tools:

ELK Stack (Elasticsearch + Logstash + Kibana)
Splunk
Fluentd

Security Monitoring (DevSecOps)

Detects security threats.

Examples:

suspicious login attempts
container runtime attacks
abnormal network traffic

Tools:

Falco
Wazuh
Security SIEM platforms

Observability

Modern DevOps focuses on Observability, not just monitoring.

Observability uses three pillars:

1. Metrics

Numerical system data.

Examples:

CPU usage
Request count
Latency

2. Logs

Detailed event records.

Example:

2026-03-13 10:45:22 User login successful

3. Traces

Track requests across micro services.

Example:

User Request
   ↓
API Gateway
   ↓
Auth Service
   ↓
Payment Service

Tracing tools:

Jaeger
Zipkin
OpenTelemetry

Monitoring Architecture

Typical DevOps monitoring architecture:

Application / Infrastructure
        │
        ▼
Metrics Exporters
        │
        ▼
Prometheus Server
        │
        ▼
Grafana Dashboards
        │
        ▼
Alert Manager
        │
        ▼
Slack / Email / PagerDuty Alerts

Monitoring Tools (Enterprise)

CategoryToolsMetrics monitoringPrometheusVisualizationGrafanaLogsELK StackTracingJaegerAlertingAlertManagerAPMDatadog

Alerts and Incident Management

Monitoring systems generate alerts when thresholds are exceeded.

Example:

CPU usage > 90%
API response time > 500ms
Error rate > 5%

Alert workflow:

Monitoring system
      ↓
Alert triggered
      ↓
PagerDuty / Slack
      ↓
On-call engineer notified

DORA metrics and engineering performance

Let’s look at the four DORA metrics:

Deployment frequency (DF)
Lead time (LT)
Change failure rate (CFR)
Mean time to recovery (MTTR)

Deployment Frequency

Definition

How often a team deploys code to production.

It measures delivery speed.

Example

If a team deploys:

Monday → 3 deployments
Tuesday → 2 deployments
Wednesday → 4 deployments

Total deployments:

9 deployments per week

Deployment frequency:

~1.3 deployments per day

Why It Matters

Higher deployment frequency means:

Faster feature delivery
Smaller code changes
Faster feedback cycles

SDLC vs DevOps

What is SDLC?

SDLC (Software Development Life Cycle) is a structured process used to design, develop, test, and deploy software.

It defines sequential stages for building software.

Typical SDLC flow:

Requirements → Design → Development → Testing → Deployment → Maintenance

Traditional SDLC Stages

1. Requirements Gathering

Business requirements are collected.

Example:

User authentication
Payment system
Dashboard analytics

Tools used:

Jira
Confluence
Documentation

2. System Design

System architecture is designed.

Example:

User
  ↓
Frontend
  ↓
Backend API
  ↓
Database

Outputs:

architecture diagrams
system design documents

3. Development

Developers write code.

Example:

git clone repository
write code
commit changes

Programming languages:

Java
Python
NodeJS

4. Testing

Quality assurance team tests the application.

Types of testing:

Unit testing
Integration testing
System testing
User acceptance testing

Testing was traditionally manual.

5. Deployment

Application is deployed to production.

Example:

Build application
Upload artifact
Restart server

Deployments were usually manual and infrequent.

6. Maintenance

Fix bugs and update features.

Example tasks:

patch vulnerabilities
fix production issues
add new features

3️⃣ Problems with Traditional SDLC

Traditional SDLC had many challenges.

Slow releases

Example:

1 release every 3–6 months

Poor collaboration

Teams worked separately.

Example workflow:

Developers → QA → Operations

This caused delays.

Traditional SDLC Stages

1. Requirements Gathering

Business requirements are collected.

Example:

User authentication
Payment system
Dashboard analytics

Tools used:

Jira
Confluence
Documentation

2. System Design

System architecture is designed.

Example:

User
  ↓
Frontend
  ↓
Backend API
  ↓
Database

Outputs:

architecture diagrams
system design documents

3. Development

Developers write code.

Example:

git clone repository
write code
commit changes

Programming languages:

Java
Python
NodeJS

4. Testing

Quality assurance team tests the application.

Types of testing:

Unit testing
Integration testing
System testing
User acceptance testing

Testing was traditionally manual.

5. Deployment

Application is deployed to production.

Example:

Build application
Upload artifact
Restart server

Deployments were usually manual and infrequent.

Maintenance

Fix bugs and update features.

Example tasks:

patch vulnerabilities
fix production issues
add new features

3️⃣ Problems with Traditional SDLC

Traditional SDLC had many challenges.

4️⃣ What is DevOps?

DevOps is a culture and set of practices that combines development and operations.

Goal:

faster software delivery
better collaboration
automated processes

DevOps lifecycle:

Plan → Code → Build → Test → Release → Deploy → Operate → Monitor

5️⃣ DevOps Approach

Instead of sequential phases, DevOps uses continuous cycles.

Example workflow:

Developer commits code
      ↓
CI pipeline builds code
      ↓
Automated tests run
      ↓
Application deployed automatically
      ↓
Monitoring collects feedback

This process repeats continuously.

6️⃣ SDLC vs DevOps Lifecycle

Traditional SDLC:

Requirements
     ↓
Design
     ↓
Development
     ↓
Testing
     ↓
Deployment

DevOps lifecycle:

Plan
 ↓
Code
 ↓
Build
 ↓
Test
 ↓
Deploy
 ↓
Monitor
 ↓
Feedback

DevOps creates a continuous loop instead of a linear process.Traditional SDLC Stages

1. Requirements Gathering

Business requirements are collected.

Example:

User authentication
Payment system
Dashboard analytics

Tools used:

Jira
Confluence
Documentation

2. System Design

System architecture is designed.

Example:

User
  ↓
Frontend
  ↓
Backend API
  ↓
Database

Outputs:

architecture diagrams
system design documents

3. Development

Developers write code.

Example:

git clone repository
write code
commit changes

Programming languages:

Java
Python
NodeJS

4. Testing

Quality assurance team tests the application.

Types of testing:

Unit testing
Integration testing
System testing
User acceptance testing

Testing was traditionally manual.

5. Deployment

Application is deployed to production.

Example:

Build application
Upload artifact
Restart server

Deployments were usually manual and infrequent.

6. Maintenance

Fix bugs and update features.

Example tasks:

patch vulnerabilities
fix production issues
add new features

3️⃣ Problems with Traditional SDLC

Traditional SDLC had many challenges.

Slow releases

Example:

1 release every 3–6 months

Poor collaboration

Teams worked separately.

Example workflow:

Developers → QA → Operations

This caused delays.

Manual processes

Deployments required manual steps.

Example:

copying files
restarting servers

Late bug detection

Bugs found during testing phase.

Fixing them was expensive.

4️⃣ What is DevOps?

DevOps is a culture and set of practices that combines development and operations.

Goal:

faster software delivery
better collaboration
automated processes

DevOps lifecycle:

Plan → Code → Build → Test → Release → Deploy → Operate → Monitor

5️⃣ DevOps Approach

Instead of sequential phases, DevOps uses continuous cycles.

Example workflow:

Developer commits code
      ↓
CI pipeline builds code
      ↓
Automated tests run
      ↓
Application deployed automatically
      ↓
Monitoring collects feedback

This process repeats continuously.

6️⃣ SDLC vs DevOps Lifecycle

Traditional SDLC:

Requirements
     ↓
Design
     ↓
Development
     ↓
Testing
     ↓
Deployment

DevOps lifecycle:

Plan
 ↓
Code
 ↓
Build
 ↓
Test
 ↓
Deploy
 ↓
Monitor
 ↓
Feedback

DevOps creates a continuous loop instead of a linear process.Traditional SDLC Stages

1. Requirements Gathering

Business requirements are collected.

Example:

User authentication
Payment system
Dashboard analytics

Tools used:

Jira
Confluence
Documentation

2. System Design

System architecture is designed.

Example:

User
  ↓
Frontend
  ↓
Backend API
  ↓
Database

Outputs:

architecture diagrams
system design documents

3. Development

Developers write code.

Example:

git clone repository
write code
commit changes

Programming languages:

Java
Python
NodeJS

Testing

Quality assurance team tests the application.

Types of testing:

Unit testing
Integration testing
System testing
User acceptance testing

Testing was traditionally manual.

Deployment

Application is deployed to production.

Example:

Build application
Upload artifact
Restart server

Deployments were usually manual and infrequent.

Maintenance

Fix bugs and update features.

Example tasks:

patch vulnerabilities
fix production issues
add new features

Problems with Traditional SDLC

Traditional SDLC had many challenges.

Slow releases

Example:

1 release every 3–6 months

Poor collaboration

Teams worked separately.

Example workflow:

Developers → QA → Operations

This caused delays.

Manual processes

Deployments required manual steps.

Example:

copying files
restarting servers

Late bug detection

Bugs found during testing phase.

Fixing them was expensive.

What is DevOps?

DevOps is a culture and set of practices that combines development and operations.

Goal:

faster software delivery
better collaboration
automated processes

DevOps lifecycle:

Plan → Code → Build → Test → Release → Deploy → Operate → Monitor

DevOps Approach

Instead of sequential phases, DevOps uses continuous cycles.

Example workflow:

Developer commits code
      ↓
CI pipeline builds code
      ↓
Automated tests run
      ↓
Application deployed automatically
      ↓
Monitoring collects feedback

This process repeats continuously.

SDLC vs DevOps Lifecycle

Traditional SDLC:

Requirements
     ↓
Design
     ↓
Development
     ↓
Testing
     ↓
Deployment

DevOps lifecycle:

Plan
 ↓
Code
 ↓
Build
 ↓
Test
 ↓
Deploy
 ↓
Monitor
 ↓
Feedback

DevOps creates a continuous loop instead of a linear process.Manual processes

Deployments required manual steps.

Example:

copying files
restarting servers

Late bug detection

Bugs found during testing phase.

Fixing them was expensive.

What is DevOps?

DevOps is a culture and set of practices that combines development and operations.

Goal:

faster software delivery
better collaboration
automated processes

DevOps lifecycle:

Plan → Code → Build → Test → Release → Deploy → Operate → Monitor

DevOps Approach

Instead of sequential phases, DevOps uses continuous cycles.

Example workflow:

Developer commits code
      ↓
CI pipeline builds code
      ↓
Automated tests run
      ↓
Application deployed automatically
      ↓
Monitoring collects feedback

This process repeats continuously.

SDLC vs DevOps Lifecycle

Traditional SDLC:

Requirements
     ↓
Design
     ↓
Development
     ↓
Testing
     ↓
Deployment

DevOps lifecycle:

Plan
 ↓
Code
 ↓
Build
 ↓
Test
 ↓
Deploy
 ↓
Monitor
 ↓
Feedback

DevOps creates a continuous loop instead of a linear process.

Draw a DevOps lifecycle diagram.

PLAN
  │
  │ Tools:
  │ Jira, Azure Boards
  ▼
CODE
  │
  │ Tools:
  │ Git, GitHub, GitLab
  ▼
BUILD
  │
  │ Tools:
  │ Maven, Gradle
  ▼
TEST
  │
  │ Tools:
  │ JUnit, Selenium
  ▼
RELEASE
  │
  │ Tools:
  │ Jenkins, GitHub Actions
  ▼
DEPLOY
  │
  │ Tools:
  │ Docker, Kubernetes
  ▼
OPERATE
  │
  │ Tasks:
  │ Infrastructure management
  ▼
MONITOR
  │
  │ Tools:
  │ Prometheus, Grafana
  ▼
FEEDBACK → Improve system

PLAN → Jira
CODE → Git
BUILD → Maven
TEST → Selenium
RELEASE → Jenkins
DEPLOY → Kubernetes
OPERATE → Cloud Infrastructure
MONITOR → Prometheus

Write notes explaining CI vs CD vs Continuous Deployment.

1️⃣ Continuous Integration (CI)

Definition: Continuous Integration is the practice where developers frequently merge code into a shared repository, and each commit triggers automated builds and tests.

Purpose

detect bugs early
maintain code quality

Workflow

Developer Commit
      ↓
Git Repository
      ↓
CI Pipeline
      ↓
Build + Automated Tests

Example tools

Jenkins
GitHub Actions
GitLab CI

2️⃣ Continuous Delivery (CD)

Definition: Continuous Delivery ensures that the application is always ready for deployment, but production deployment requires manual approval.

Workflow

Code Commit
     ↓
Build + Tests
     ↓
Artifact Created
     ↓
Manual Approval
     ↓
Production Deployment

Purpose

reliable releases
controlled deployments

3️⃣ Continuous Deployment

Definition: Continuous Deployment automatically deploys every successful build to production without manual approval.

Workflow

Code Commit
     ↓
Build + Tests
     ↓
Security Checks
     ↓
Automatic Deployment

Purpose

fastest feature delivery
quick feedback from users

Understand CI/CD workflow diagram.

CI/CD Workflow (Short Explanation)

A CI/CD workflow shows how code moves from development to production automatically using pipelines.

Typical workflow:

Developer
   ↓
Code Commit (Git)
   ↓
CI Pipeline Trigger
   ↓
Build Application
   ↓
Run Automated Tests
   ↓
Create Artifact
   ↓
Deploy to Environment
   ↓
Monitor Application

Step-by-Step Understanding

1️⃣ Code Commit Developers push code to a repository (GitHub / GitLab).

2️⃣ CI Pipeline Trigger The CI system automatically starts a pipeline.

3️⃣ Build Stage Application is compiled or packaged.

4️⃣ Testing Stage Automated tests run (unit tests, integration tests).

5️⃣ Artifact Creation Build output is stored (Docker image, JAR file).

6️⃣ Deployment Application is deployed to staging or production.

7️⃣ Monitoring Monitoring tools track performance and errors.

Example DevOps CI/CD Pipeline

Developer
   ↓
Git Repository
   ↓
Jenkins Pipeline
   ↓
Build + Tests
   ↓
Docker Image
   ↓
Kubernetes Deployment
   ↓
Prometheus Monitoring

List common DevOps tools used in enterprises.

Common DevOps Tools (Short List)
Planning / Project Management: Jira, Azure Boards
Source Control: Git, GitHub, GitLab, Bitbucket
CI/CD: Jenkins, GitHub Actions, GitLab CI
Build Tools: Maven, Gradle
Containerization: Docker
Container Orchestration: Kubernetes
Artifact Repository: Nexus, Artifactory
Infrastructure as Code: Terraform, Ansible
Monitoring: Prometheus, Grafana
Logging: ELK Stack (Elasticsearch, Logstash, Kibana)

Write notes for interview.

DevOps Fundamentals — Interview Question List

Basic DevOps

What is DevOps?
What are the key principles of DevOps?
What is the DevOps lifecycle?
What problems does DevOps solve?
What is the CAMS model in DevOps?

CI/CD

What is Continuous Integration (CI)?
What is Continuous Delivery?
What is Continuous Deployment?
What is the difference between CI, CD, and Continuous Deployment?
What is a CI/CD pipeline?

DevOps Workflow

How does a CI/CD workflow work?
What stages are typically included in a CI/CD pipeline?
What is an artifact in a CI/CD pipeline?
How do you trigger a CI/CD pipeline?

DevOps Metrics

What are DORA metrics?
What is Deployment Frequency?
What is Lead Time for Changes?
What is Change Failure Rate?
What is Mean Time to Recovery (MTTR)?

SDLC and DevOps

What is SDLC?
What is the difference between SDLC and DevOps?
How does DevOps improve the SDLC process?

DevOps Tools

What tools are commonly used in DevOps?
What is Jenkins used for?
What is Docker?
What is Kubernetes used for?
What tools are used for monitoring in DevOps?

Architecture / Workflow

Explain a typical DevOps pipeline architecture.
How does monitoring fit into the DevOps lifecycle?
How does feedback improve DevOps processes?

메타데이터

post_id: 6ea0cd7bcb25
slug: devops-fundamentals-6ea0cd7bcb25
url: https://medium.com/@rahul.bobadi/devops-fundamentals-6ea0cd7bcb25
canonical_url: https://medium.com/@rahul.bobadi/devops-fundamentals-6ea0cd7bcb25
author_url: https://medium.com/@rahul.bobadi
status: ok
fetched_at: 2026-07-06 23:18:09