TL;DR

• You need four things, nothing more: a laptop, AI, time, and commitment. No budget, no cohort.
• Build one small reference app first (Python + PostgreSQL). Prove it runs standalone, then in Docker. This is a requirement, not optional, and you deploy this same app at every level.
• Get the AI to draft a personal learning plan around that app, not a generic course. Tell it your background, your hours per week, and whether certification matters to you.
• Certification (CKA/CKAD) is optional. It may help with jobs or promotions, it costs money and time, and this series doesn’t require it either way.
• Learn through AI Q&A, not lectures: get quizzed, explain concepts back, get pushed on guesses.
• Round it out with YouTube for what needs to be seen, AI-generated diagrams mid-conversation, and the official Kubernetes docs, which are better as a learning tool than most people realize.
• Turn the AI’s draft plan into real commitments with a “done” bar per level.
• Prompt for learning, not answers: put the first attempt on yourself, use the AI to check it.
• Take notes in your own words, and draw diagrams, on paper or in a tool like Excalidraw.
• Type new YAML and commands yourself instead of copy-pasting; it’s where you catch mistakes.

What This Actually Takes

You need four things to learn Kubernetes this way, and nothing beyond them: a laptop, access to AI, time, and commitment. No budget line, no employer-sponsored training slot, no waiting for a cohort to start.

Vibe Coding - The Background

The year is 2025. The way we build software—whether it’s a simple three-page website or a complex system with dozens of microservices—has undergone a dramatic transformation. We’ve shifted from scouring forums like Stack Overflow and reading technical blogs found via Google to having interactive conversations with LLMs (Large Language Models) and AI agents.

AI and LLMs have democratized access to technology. Today, you don’t need a formal background in software engineering to create websites or applications. With the help of AI, anyone can build software. This cultural shift is now often called “Vibe Coding.”

Previously, I wrote about modern-day education. In this post, let’s explore how the role of the college lecturer has evolved over time.

Traditionally, lecturers were at the heart of higher education. Their primary responsibility was to deliver lectures—bringing a human touch to the world of reading and writing. These sessions, often informal in tone, helped break down complex topics into digestible chunks. The setting was familiar: four walls, a blackboard and chalk—or later, a whiteboard and marker.

As developers, we often get comfortable with a language and ecosystem, mastering its quirks and nuances. But what happens when we need to step out of our comfort zone? What if the best tool for the job is in a language we haven’t touched before? The transition from one language to another used to be a daunting task, requiring days of reading books, writing small programs, and debugging mysterious errors. However, in the era of AI-assisted development, this learning curve has flattened significantly.

In the past, formal education was primarily accessible through schools, colleges, and universities. However, this is no longer the only path to gaining knowledge. Today, with the vast array of modern tools and technologies available online, self-education has become more viable than ever. If you have the motivation and discipline, you can learn virtually any subject without attending a traditional institution.

Education is now widely accessible through various online resources, including:

The Tech Chorus DevOps Platform

Over the last decade, the way we develop and deploy software has transformed significantly. This transformation has brought together various sub-disciplines, collectively known as DevOps engineering, including:

• IT Engineering: Focused on hardware and networking infrastructure.
• System Administration: Responsible for managing servers in racks, data centers, or colocation services.
• Cloud Infrastructure Engineering: Specializes in managing public cloud infrastructure.
• Platform Engineering: Builds and maintains platforms for deploying software applications, abstracting away complexity for users.

Introducing the Tech Chorus DevOps Platform

The Tech Chorus DevOps Platform is both a framework and software platform designed to host and run software applications and services. It facilitates the creation of cloud-based infrastructure from scratch and adheres to an opinionated approach, integrating best practices and tradeoffs. The platform offers a reference architecture and implementation to meet the most common use cases, with a strong emphasis on open-source technologies.

Introduction

In our last post, we wrote some Python functions in preparation to implement the RSA algorithm. In this post, we will implement the RSA algorithm.

Program On The Receiver’s Side

Create the public and private keys. Share the public key with the sender.

import random
from sympy import isprime

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

def modinv(a, m):
    m0, x0, x1 = m, 0, 1
    if m == 1:
        return 0
    while a > 1:
        q = a // m
        m, a = a % m, m
        x0, x1 = x1 - q * x0, x0
    if x1 < 0:
        x1 += m0
    return x1

def generate_prime_candidate(length):
    p = random.getrandbits(length)
    # Apply a mask to set MSB and LSB to 1 to ensure a proper length prime
    p |= (1 << length - 1) | 1
    return p

def generate_large_prime(length=1024):
    p = 4
    while not isprime(p):
        p = generate_prime_candidate(length)
    return p

def generate_keypair(keysize):
    p = generate_large_prime(keysize)
    q = generate_large_prime(keysize)
    n = p * q
    phi = (p - 1) * (q - 1)

    # Choose e
    e = random.randrange(2, phi)
    g = gcd(e, phi)
    while g != 1:
        e = random.randrange(2, phi)
        g = gcd(e, phi)

    # Generate d
    d = modinv(e, phi)

    return ((n, e), (n, d))

def decrypt(private_key, ciphertext):
    n, d = private_key
    # Decrypt each character
    plain = [chr((char ** d) % n) for char in ciphertext]
    return ''.join(plain)

# RSA Key Generation
keysize = 8  # Small size for demonstration; use 1024 or 2048 for real applications
public_key, private_key = generate_keypair(keysize)

print(f"Public Key: {public_key}")
print(f"Private Key: {private_key}")

Execute the program on the receiver’s computer. Take note of the public and private key. Share the public key with the sender.

Prerequisites

• Familiarity with binary arithmetic. Know what are MSB and LSB.
• Bitwise operations. Logical shift.
• Primality Testing

Introduction

Continuing with the series of posts on number theory and cryptograpy, let us take a look at the RSA algorithm.

Before writing the RSA program, let’s prepare some useful functions.

GCD

Here’s a simple recurisve function to computed the GCD of two integers.

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

We have discussed the non-recursive implementation of the Euclidean algorithm at length in this series.

Introduction

Continuing with the series of posts on number theory and cryptograpy, let us take a look at the RSA algorithm.

RSA is an algorithm to perform encryption and decryption of data.

The Basic Idea

RSA uses two keys to encrypt and decrypt messages:

• Public Key: Anyone can see this key. It’s used to encrypt the message.
• Private Key: Only you should know this key. It’s used to decrypt the message.

When someone wants to send you a secret message, they use your public key to encrypt the message. Once it’s encrypted, only your private key can decrypt it.

Introduction

Continuing with the series of posts on number theory and cryptograpy, let us take a look at the Euler’s Totient Function.

Euler’s Totient Function, denoted as ϕ(n), is a function that counts the number of positive integers less than or equal to n that are relatively prime to n. Two numbers are relatively prime (or coprime) if their greatest common divisor (GCD) is 1.

Prerequisites

• Familarity with the Inclusion-Exclusion principle
• Familarity with the modular arithmetic

Definition

For any positive integer n, the Euler’s Totient Function ϕ(n) is defined as: