🪴LYC

🪴LYC

CI CD

Mar 07, 2026

2026-03-07 15:32 Tags:Technical Literacy

this youtube is also very great simple straightforward https://youtu.be/scEDHsr3APg?si=U-pgUGcv0v-R1De1

Yeah — CI/CD is one of those things you see everywhere in tech but nobody explains clearly unless you’re an engineer. Once you understand it, a lot of startup and software workflows suddenly make sense.

Let’s break it down simply.

1. First: what CI/CD stands for

CI = Continuous Integration
CD = Continuous Delivery / Continuous Deployment

It’s a system that automatically builds, tests, and deploys software when code changes.

Think of it as an automation pipeline for software updates.

2. The old way of shipping software

Before CI/CD, developers released software manually.

Example process:

  1. Write code

  2. Manually test it

  3. Package the software

  4. Upload to server

  5. Restart system

This could take days or weeks.

Also risky — a mistake could crash production.

3. CI/CD automates the whole process

Modern teams automate everything.

Example pipeline:

Developer pushes code
      ↓
Tests run automatically
      ↓
Code builds
      ↓
Deploy to server

This entire pipeline runs automatically.

4. Where CI comes in

CI = Continuous Integration

When developers add code, the system immediately checks it.

Example workflow:

Developer commits code
      ↓
CI pipeline starts
      ↓
Run tests
      ↓
Check code quality
      ↓
Build project

If tests fail:

❌ deployment stops

So broken code never reaches production.

5. Where CD comes in

CD = Continuous Delivery / Deployment

Once code passes CI, the system deploys it automatically.

Example:

Code passes tests
      ↓
Deploy to staging
      ↓
Deploy to production

This can happen multiple times per day.

6. The full CI/CD pipeline

Example modern workflow:

Developer pushes code to GitHub
        ↓
CI system runs tests
        ↓
Build container
        ↓
Deploy to cloud server
        ↓
Users see new feature

All automatic.

7. Where webhooks appear

Remember what we talked about earlier: webhooks trigger automation.

When a developer pushes code to
GitHub

GitHub sends a webhook.

Example:

GitHub → webhook → CI server

This triggers the pipeline.

Example CI tools:

  • GitHub Actions

  • Jenkins

  • GitLab CI

  • CircleCI

8. Example: GitHub Actions pipeline

Example workflow:

Push code to GitHub
      ↓
GitHub Actions starts
      ↓
Run tests
      ↓
Build application
      ↓
Deploy to server

Developers don’t need to do anything manually.

9. Why startups rely on CI/CD

CI/CD allows teams to move extremely fast.

Instead of releasing every few months:

Companies like
Netflix
and
Amazon

deploy hundreds or thousands of times per day.

Every small change goes through CI/CD.

10. Real-life analogy

Imagine writing a book.

Old method:

Write entire book
      ↓
Send to editor
      ↓
Publish

CI/CD method:

Write paragraph
      ↓
Spellcheck automatically
      ↓
Grammar check automatically
      ↓
Publish update instantly

Continuous improvement.

11. Why you see CI/CD everywhere

If you explore tech tools or startup documentation, you’ll see it constantly because it’s core infrastructure for software teams.

Whenever code changes, CI/CD ensures:

  • nothing breaks

  • everything builds

  • updates reach users quickly

12. Why this matters for your learning

You’re already learning things close to this ecosystem:

  • APIs

  • webhooks

  • automation workflows

  • developer tools

CI/CD sits in the same infrastructure layer.

Understanding these systems helps you think like:

  • a product builder

  • a startup operator

  • a technical founder

Great question. This is actually the “big map” of how modern software gets built and shipped. Once you see it, many tools suddenly make sense.

I’ll walk through it like a story of one code change moving through the system.

1. Step 1 — Writing code (Git)

Developers write code on their computer and track changes with
Git.

Git is basically a history system for code.

Example:

git add .
git commit -m "Add payment feature"

Git records:

  • what changed

  • when it changed

  • who changed it

So you never lose work.

2. Step 2 — Sharing code (GitHub)

Next the developer pushes the code to
GitHub.

git push origin main

Now the code lives online where the team can collaborate.

GitHub provides:

  • code hosting

  • collaboration

  • pull requests

  • issue tracking

Think of GitHub as Google Docs for code.

3. Step 3 — Webhook triggers CI/CD

When code is pushed to GitHub, something interesting happens.

GitHub sends a webhook event.

Example:

event: code pushed
repository: project-x
branch: main

This webhook triggers the CI/CD system.

Example tools:

  • GitHub Actions

  • Jenkins

  • GitLab CI

So the flow is:

GitHub → webhook → CI pipeline

4. Step 4 — Continuous Integration runs tests

The CI system automatically checks the code.

Example pipeline:

Run tests
Check formatting
Compile code
Build application

If something breaks:

❌ deployment stops

This prevents broken code from reaching production.

5. Step 5 — Build the application

If tests pass, the system builds the application.

Example:

source code → runnable application

Often this means creating a container (Docker image).

Example:

App + dependencies → container image

This ensures the software runs the same everywhere.

6. Step 6 — Deploy to the cloud

The built application is deployed to cloud infrastructure.

Example platforms:

  • Amazon Web Services

  • Google Cloud

  • Microsoft Azure

Deployment means:

Upload application
Start servers
Expose API endpoints

Now users can access the service.

7. Step 7 — APIs power the application

Once deployed, the application exposes APIs.

Example:

GET /users
POST /orders
GET /payments

Other systems communicate with these APIs.

Example architecture:

Mobile App
     ↓
API Server
     ↓
Database

Or:

Service A → API → Service B

8. The full system map

Now we combine everything.

Developer writes code
        ↓
Git tracks changes
        ↓
Push to GitHub
        ↓
Webhook triggers CI/CD
        ↓
Tests + build pipeline
        ↓
Deploy to cloud
        ↓
Application runs
        ↓
APIs serve users

This loop repeats continuously.

9. What users see

Users don’t see the infrastructure.

They only see:

Website
Mobile app
Software product

But behind the scenes this entire pipeline is running.

10. Example: updating a feature

Imagine you fix a bug.

The process might look like this:

Fix code locally
        ↓
git commit
        ↓
git push
        ↓
GitHub webhook triggers CI
        ↓
Tests pass
        ↓
Deploy automatically
        ↓
Users get the fix

Total time: sometimes 5–10 minutes.

11. Why this system is powerful

It enables:

  • fast development

  • safe updates

  • global scaling

Companies like
Netflix and
Amazon

deploy code thousands of times per day using this pipeline.

12. Why this matters for you

You’re already touching pieces of this system:

  • automation workflows

  • APIs

  • webhooks

  • technical infrastructure

Understanding this pipeline means you can think like:

  • a technical product builder

  • a startup operator

  • a technical founder

Even if you don’t become a full engineer.

If you want, I can also show you something fascinating that many non-engineers never realize:

Why the entire modern internet is basically “APIs + cloud + automation pipelines”.

Once you see that architecture, it explains how startups with 5–10 engineers can build massive products.

Graph View

Backlinks