Friday, May 22, 2026

Cohort 3 | Project CloudIgnite Topics: Automation & Orchestration, Project Infrastructure, Configuration Management, DevOps & CI/CD Duration: ~3 hours

Key Takeaways

• Automation vs orchestration: automation = single task; orchestration = coordinating multiple automated tasks
• Monolithic vs microservices: one repo/server vs independent services (Netflix example)
• Naming conventions: camelCase, PascalCase, snake_case, kebab-case, UPPER_CASE
• PyLint: code style checker; PyTest: unit testing framework with assert statements
• Version control: git workflow, merge conflicts require manual resolution
• Semantic versioning: MAJOR.MINOR.PATCH
• CI/CD tools: Jenkins, GitHub Actions, GitLab CI/CD, AWS CodeDeploy, CircleCI
• Security warning: pushed API keys persist in git history; use .gitignore and rotate keys immediately

Table of Contents

1. Lab Work – Automation Topics (Lab 135 & 136)
2. The Value of Automation
3. Automation vs. Orchestration
4. Project Infrastructure & Architecture
5. Code Organisation & Coding Styles
6. Tools: PyLint & PyTest
7. Configuration Management & Version Control
8. DevOps & CI/CD
9. CLF-C02 Exam Relevance
10. Admin & Cohort Updates

1. Lab Work – Automation Topics (Lab 135 & 136)

Lab 135 – Explore the Value of Automation (Q&A Format)

Key questions covered:

Lab 136 – Compare and Contrast Automation and Orchestration

A classification exercise. Key guidance on categorising concepts:

2. The Value of Automation

"Automation reduces human errors and makes repetitive tasks faster and more efficient." — Paul

Core principles discussed:

• Primary value: Removes repetitive tasks from humans, reducing error and increasing output
• Cost reduction: Fewer people needed for repetitive work, but Paul's philosophy is that automation should redirect humans to higher-value work, not eliminate jobs
• Complementary roles: Freed-up humans should focus on tasks that cannot (yet) be automated — creativity, decision-making, critical judgement

Why NOT automate everything in DevOps?

• Cost – automation infrastructure isn't free
• Security risks – automated systems can be exploited
• Compliance issues – some processes require human sign-off
• Complex / critical tasks – things that need manual review or legal accountability
• Decision-making scenarios – you cannot automate judgement calls

3. Automation vs. Orchestration

HCL (HashiCorp Configuration Language) was briefly mentioned — a language used by Terraform for infrastructure provisioning (automation/orchestration of cloud infrastructure).

4. Project Infrastructure & Architecture

Monolithic vs. Microservices

Netflix is built on microservice architecture. Each feature (landing page, content browser, streaming backend) runs in a separate service/repository.

MonoRepo

• Still one repository, but front-end and back-end are separated within it
• Not the same as monolithic — the concern is code organisation, not deployment coupling
• Downside: version control tools like Git can slow down at scale

Middleware

• Software that connects different systems — described as "software glue"
• Not front-end or back-end; sits between them to enable communication

5. Code Organisation & Coding Styles

Why standardise coding style in a team?

When multiple developers work on the same codebase, inconsistent styles cause:

• Merge conflicts that are hard to resolve
• Onboarding friction for new team members
• Reduced readability and maintainability

Common Naming Conventions

Note: Some languages restrict naming. C/C++ variable names can only use A-Z, a-z, 0-9, and _ — so kebab-case is not valid.

6. Tools: PyLint & PyTest

PyLint – Code Style Checker

• Scans Python code and checks it against a defined coding standard
• Analogy: like a lint roller — it removes the "debris" (style violations) from your code
• Saves developers from manually reviewing thousands of lines for indentation or naming errors
• You configure it with your team's standard, and it automatically enforces it

PyTest – Logic / Unit Testing Framework

• Allows you to write test cases that verify your code produces the expected output
• You must write the tests yourself (the "painful" part)
• Example: if your function should return all prime numbers from 1–250, your test provides the expected list and checks that the function output matches
• Uses assert statements to compare expected vs. actual output
• Part of CI/CD pipelines to automatically verify code before merging

7. Configuration Management & Version Control

What is Configuration Management?

Also called version control software. It:

• Tracks all code changes and who made them (with timestamps)
• Enables rollback to any previous working version ("like a time machine")
• Enables team collaboration on the same codebase

Git Workflow (Basic)

# Clone a repository
git clone <repo-url>

# Stage changes
git add .

# Commit with a message
git commit -m "your message"

# Push to remote
git push origin main

Merge Conflicts

• Occur when two developers modify the same line of code in different branches
• Resolution: each developer works on their own branch → branches are merged → conflicts are resolved manually by the developers
• Cannot be fully automated — human review is required

⚠️ If you accidentally push an API key, simply deleting the commit is not enough — it may still exist in git history. Use .gitignore to prevent secrets from being committed in the first place, and rotate/revoke exposed keys immediately.

Software Versioning (Semantic Versioning)

Format: MAJOR.MINOR.PATCH (e.g., v2.1.3)

Tools

• GitHub – most widely used; tracks commits, authors, and timestamps; private repos now free
• GitLab – alternative to GitHub with built-in CI/CD
• Visual Studio Code – has Git version control built in (sidebar panel)

8. DevOps & CI/CD

What is DevOps?

A set of practices and a culture that helps automate and monitor software development across the full lifecycle.

CI/CD Pipeline Stages

Key Points

• A DevOps engineer sets up processes (e.g., scanning a Git repo and triggering a build when a new commit is detected)
• Compilation = Build (not deployment)
• Common CI/CD tools: Jenkins, GitHub Actions, GitLab CI/CD, CircleCI, AWS CodeDeploy
• Juniors typically know CI but not CD — setting up Jenkins and automated test scripts is considered intermediate/senior knowledge

9. CLF-C02 Exam Relevance

The following topics discussed in this lecture are directly relevant to the AWS Certified Cloud Practitioner (CLF-C02) exam:

✅ Directly Exam-Relevant

⚠️ Contextual / Background Knowledge

📝 Key CLF-C02 Services to Study from This Lecture's Context

• AWS CodeDeploy – automated deployments
• AWS CodePipeline – end-to-end CI/CD orchestration
• AWS CodeBuild – managed build service
• AWS CodeCommit – managed Git repositories
• AWS CloudFormation – infrastructure as code (IaC)
• AWS Systems Manager – configuration management at scale
• AWS Config – track configuration changes and compliance
• Amazon ECS / EKS / AWS Lambda – services that support microservice architectures

10. Admin & Cohort Updates

• Cohort end date: 27 July (tentative)
• Extension: ~4 weeks extension planned for all cohorts (cohorts 1, 2, and 3) due to insufficient time
• Future cohorts: Will be extended to 15 weeks (up from 12)
• Exam voucher eligibility: Requires 80% attendance + completion of all labs and KCs
• Access to Canvas: Lost once the cohort ends — complete all labs and KCs before then
• Exam format: Online (camera required) or face-to-face at a test centre
• AWS exam voucher validity: 6 months from issue date — don't delay too long after cohort ends
• Exam timing: Taking the exam 3–4 weeks after the course ends is acceptable
• No AWS Solutions Architect Associate training provided in this program — only Cloud Practitioner (CLF-C02)
• Practice questions for exam prep are being prepared by the Forward College team

Quick Reference – Key Concepts Summary

Automation   → Single, repetitive task executed automatically
Orchestration → Coordinating multiple automated tasks/systems

Monolithic   → One repo, one server, everything together
Microservices → Each service in its own repo/server (e.g., Netflix)

CI           → Plan → Code → Build → Test (automate merging & testing)
CD           → Deploy → Release (automate delivery to production)

PyLint       → Checks coding style (like a lint roller for code)
PyTest       → Runs unit tests to verify logic correctness

Git          → Version control; tracks who changed what and when
Versioning   → MAJOR.MINOR.PATCH (e.g., v2.1.3)

Notes compiled from Tactiq – May 22, 2026 session.