DEV Community: Sherdil IT Academy

I Simulated 3 Training Paths to See Which Breaks Even Fastest

Sherdil IT Academy — Fri, 09 Oct 2026 07:05:31 +0000

"Just do it yourself for free" and "pay for a structured program" get argued as if one is obviously right. Neither is, on its own, because they trade cost for time differently, and time has a cost too. Here's a small simulation that makes the tradeoff explicit instead of arguing about it in the abstract.

The three paths, modeled

def months_to_breakeven(upfront_cost, months_to_hireable, monthly_salary_lift, opportunity_cost_per_month=0):
    """
    upfront_cost:            cash spent on the path itself
    months_to_hireable:      realistic months until the new skill is job-ready
    monthly_salary_lift:     salary increase once hired/promoted into the role
    opportunity_cost_per_month: income foregone each month while training (0 if studying alongside a job)
    """
    total_cost = upfront_cost + (opportunity_cost_per_month * months_to_hireable)
    if monthly_salary_lift <= 0:
        return float("inf")
    return months_to_hireable + (total_cost / monthly_salary_lift)

paths = {
    "Self-study (free resources, alongside a job)": dict(
        upfront_cost=15_000,          # practice exams, occasional paid resource
        months_to_hireable=10,        # slower without structure or accountability
        monthly_salary_lift=35_000,
        opportunity_cost_per_month=0, # studying evenings/weekends, no income lost
    ),
    "Paid bootcamp (part-time, alongside a job)": dict(
        upfront_cost=120_000,
        months_to_hireable=4,
        monthly_salary_lift=35_000,
        opportunity_cost_per_month=0,
    ),
    "Employer-sponsored (full-time, company pays and schedules it)": dict(
        upfront_cost=0,                # employer pays
        months_to_hireable=3,
        monthly_salary_lift=20_000,    # smaller lift: often a role change, not external offer
        opportunity_cost_per_month=0,  # still salaried throughout
    ),
}

for name, params in paths.items():
    print(f"{name}: {months_to_breakeven(**params):.1f} months total to break even")

Self-study (free resources, alongside a job): 10.4 months total to break even
Paid bootcamp (part-time, alongside a job): 7.4 months total to break even
Employer-sponsored (full-time, company pays and schedules it): 3.0 months total to break even

What the numbers are actually saying

Employer-sponsored training wins by a wide margin whenever it is genuinely available, which is unsurprising, zero upfront cost and no income gap are hard to beat. The more interesting comparison is self-study against a paid bootcamp, because that is the decision most people are actually facing. In this model, the bootcamp breaks even three months sooner than self-study, purely because structure compresses the "months to hireable" number more than its PKR 120,000 fee costs in opportunity. That gap closes or reverses fast if you change one assumption: someone with strong self-discipline who can realistically hit a 5 or 6-month self-study timeline instead of 10 erases the bootcamp's advantage almost entirely.

The assumption that decides the whole comparison

months_to_hireable is doing more work in this model than the fee is. Change it and the ranking flips:

# Same self-study path, but with real discipline and a fixed weekly schedule
disciplined_self_study = dict(upfront_cost=15_000, months_to_hireable=5,
                               monthly_salary_lift=35_000, opportunity_cost_per_month=0)
print(months_to_breakeven(**disciplined_self_study))  # 5.4 months -> now beats the bootcamp

This is the honest finding: the fee is not what decides whether paid training is worth it. Your own realistic timeline is. Paying for structure is really paying to compress that one number, and whether that purchase is worth it depends entirely on how honestly you can estimate your own self-study pace, not on comparing fees.

Run it with your own numbers

Swap in your actual cost, your actual estimated timeline for each path, and your actual expected salary lift. The model is deliberately simple so you can sanity-check every input instead of trusting a black box. If you want the certification-fee side of this filled in with real 2026 pricing, here's the complete breakdown of what cloud certifications actually cost in Pakistan, hidden costs included, which plugs directly into the upfront_cost field above.

I put together the complete ROI analysis for Pakistani professionals, the full methodology, and realistic timelines by specialization, over here: Cloud Training ROI Investment Analysis for Pakistani Professionals.

Run your own months_to_hireable estimate honestly. Did self-study or paid training come out ahead for you? Drop it in the comments. 👇

I Built a Calculator So I'd Stop Guessing at Certification ROI

Sherdil IT Academy — Tue, 06 Oct 2026 09:42:03 +0000

Every certification ROI conversation I have ends up the same way: someone eyeballs a fee against a possible salary bump and calls it "probably worth it." That is not a calculation, it is a vibe. So I wrote a small calculator that forces the actual inputs onto the table, retake risk and study time included, instead of just the fee.

The model

def cert_total_cost(exam_fee, retake_probability, study_hours, hourly_value, extras=0):
    """
    exam_fee:           base exam fee, local currency
    retake_probability: 0-1, your honest odds of needing a second attempt
    study_hours:        realistic hours to prepare
    hourly_value:       what an hour of your time is worth to you (income, or opportunity cost)
    extras:              practice exams, lab credits, etc.
    """
    expected_exam_cost = exam_fee * (1 + retake_probability)
    time_cost = study_hours * hourly_value
    return round(expected_exam_cost + time_cost + extras)


def payback_months(total_cost, monthly_salary_lift):
    if monthly_salary_lift <= 0:
        return float("inf")
    return round(total_cost / monthly_salary_lift, 1)

The function most people skip in their head is retake_probability. A 30% chance of a second attempt is not a footnote, it is 30% more exam fee baked into the real cost before you have sat it once.

Running real numbers

# AZ-104, moderate confidence, studying around a full-time job
az104_cost = cert_total_cost(
    exam_fee=46_000,       # PKR
    retake_probability=0.25,
    study_hours=80,
    hourly_value=400,      # PKR/hour opportunity cost
    extras=8_000,          # practice exams
)
print(az104_cost)          # 97,500
print(payback_months(az104_cost, monthly_salary_lift=35_000))  # 2.8 months

# A Professional-level GCP exam, same assumptions scaled up
gcp_pro_cost = cert_total_cost(
    exam_fee=56_000,
    retake_probability=0.35,
    study_hours=140,
    hourly_value=400,
    extras=12_000,
)
print(gcp_pro_cost)        # 143,600
print(payback_months(gcp_pro_cost, monthly_salary_lift=45_000))  # 3.2 months

The Professional-level exam costs almost 50% more once study time and retake risk are priced in, but the payback window only stretches by about half a month, because the salary lift scales with it. That is the entire point of running the number instead of comparing fees side by side: the sticker price alone would have made the gap between these two look much larger than it actually is.

Why `hourly_value` is the variable worth arguing about

This is the input people get wrong in both directions. Set it too low and every certification looks free. Set it to your full salary rate and even a cheap exam looks expensive, because you are implicitly assuming every study hour displaced an hour of paid work, which is rarely true for evening or weekend study. A reasonable middle ground for most people is somewhere between zero and your actual hourly rate, scaled by how much that time would otherwise have gone to something valuable.

What the calculator will not tell you

It gives you a number, not a decision. It cannot tell you whether a certification's market demand is durable, or whether the skill underneath it is one you will actually enjoy using for the next few years. For a specific example of working through the certification-choice question with those non-financial factors included, here's how to decide which GCP certification to sit first, based on your actual role rather than the fee alone.

I put the full cost breakdown in one place, exam by exam with 2026 pricing, hidden costs most people forget to budget, and the complete payback math by certification, over here: Cloud Certification Costs Pakistan 2026: Is the Investment Worth It?".

Run your own numbers through this. What's your honest retake_probability, and does the payback window surprise you? Drop it in the comments. 👇

I Deployed the Same App to AWS, Azure, and GCP. Here's What Transfers.

Sherdil IT Academy — Mon, 28 Sep 2026 10:24:44 +0000

"Multi-cloud" gets thrown around as if clouds were interchangeable once you know one. They are not, but they are also not as different as vendor marketing wants you to believe. The only way to find out where the real line sits is to deploy the same thing three times and pay attention to what actually transferred. So I took one containerized app and pushed it to AWS, Azure, and GCP in the same afternoon. Here is exactly what carried over and what did not.

The same container, three CLIs

# AWS: push to ECR, deploy to App Runner
aws ecr create-repository --repository-name demo-app
docker push <account>.dkr.ecr.us-east-1.amazonaws.com/demo-app:v1
aws apprunner create-service --service-name demo-app --source-configuration file://source.json

# Azure: push to ACR, deploy to Container Apps
az acr create --name demoacr --resource-group demo-rg --sku Basic
docker push demoacr.azurecr.io/demo-app:v1
az containerapp create --name demo-app --resource-group demo-rg --image demoacr.azurecr.io/demo-app:v1

# GCP: push to Artifact Registry, deploy to Cloud Run
gcloud artifacts repositories create demo-repo --repository-format=docker --location=us-central1
docker push us-central1-docker.pkg.dev/PROJECT/demo-repo/demo-app:v1
gcloud run deploy demo-app --image us-central1-docker.pkg.dev/PROJECT/demo-app:v1

Three completely different command syntaxes. If you only measure "how many new commands did I type," multi-cloud looks brutal. That is the wrong measurement.

What actually transferred

The concepts did, almost entirely. Every one of these deployments needed the same mental checklist:

A container registry, authenticated before push
A managed compute layer that pulls from that registry and runs the container
Environment variables and secrets injected at deploy time, not baked into the image
A public endpoint with HTTPS handled for me
Logs and basic metrics available without extra setup

Once I had that checklist in my head from the AWS pass, the Azure and GCP passes were mostly "find the equivalent command," not "relearn the idea." The second cloud took under half the time of the first. The third took less than that.

What did not transfer, and cost real time

IAM was the honest exception. AWS IAM policies, Azure RBAC role assignments, and GCP IAM bindings are conceptually similar, permissions attached to identities, but the syntax, the scoping model, and the default-deny versus default-allow behavior differ enough that I made a real mistake on each cloud the first time through: an over-permissive service account here, a missing role binding there. Networking defaults were the second exception; what counts as "publicly reachable by default" is not the same answer on all three.

# The three IAM mental models, compressed
# AWS: attach a policy document to a role, mostly allow-by-exception
# Azure: assign a built-in or custom role to a principal at a scope (sub/RG/resource)
# GCP: bind a role to a member on a resource, IAM is closer to the surface everywhere

What this means for how you should actually train

If a course teaches "AWS from scratch," "Azure from scratch," and "GCP from scratch" as three unrelated modules, it is teaching the syntax three times and the concepts zero times, which is the slow way to get multi-cloud competent. The efficient path is the opposite: learn the concepts once, deep, on whichever cloud your job actually uses, then treat every additional cloud as a syntax-and-IAM problem, not a fresh start. That is a very different training design than most bootcamps run, and it is worth knowing which kind of program you are signing up for before you pay.

This distinction matters even more once you are past learning for yourself and into upskilling a whole team, where the cost of teaching three clouds as three separate courses multiplies fast. If that is the situation you are in, how corporate cloud training for development teams in Pakistan actually approaches this differently is worth reading before you scope a training budget.

I wrote up the complete case for why multi-cloud training is where the market is heading, and what a well-designed multi-cloud curriculum actually looks like, over here: Why Multi-Cloud Training Is the Future: Pakistan's Cloud Academy Landscape.

If you've deployed to more than one cloud, was IAM the thing that tripped you up too, or was it something else? Drop it in the comments. 👇

Stop Comparing Cloud Institutes by Vibes: A 20-Line Scoring Script

Sherdil IT Academy — Fri, 25 Sep 2026 11:29:32 +0000

If you are choosing a cloud training institute in Pakistan, you have probably done the same thing most people do: visited a few websites, sat through a couple of sales calls, and picked the one that felt most convincing. The problem is that "felt convincing" is exactly what a sales call is engineered to produce. So here is a way to take your own judgment out of the sales room and put it on paper: a weighted scorecard, in about twenty lines of Python.

The idea

Pick the factors that actually predict a good outcome, decide how much each one matters to you, rate every institute on each factor from 0 to 5, and let arithmetic do the comparison. The weights are the important part, because they force you to admit what you actually care about before you see any brochure.

WEIGHTS = {
    "hands_on_labs":     30,  # share of class time spent in real environments
    "instructor_current": 20,  # still working in the field, not just teaching
    "cert_alignment":    20,  # syllabus maps to the exam's published objectives
    "mentor_ratio":      15,  # realistic student-to-mentor support
    "placement_support": 10,  # interview prep, referrals, portfolio review
    "cost_transparency":  5,  # exam fees, retakes, extras stated up front
}

def score(ratings: dict) -> float:
    """ratings: each factor rated 0-5. Returns a score out of 100."""
    return sum(WEIGHTS[k] * ratings[k] / 5 for k in WEIGHTS)

institute_a = {"hands_on_labs": 4, "instructor_current": 3, "cert_alignment": 4,
               "mentor_ratio": 2, "placement_support": 3, "cost_transparency": 5}
institute_b = {"hands_on_labs": 2, "instructor_current": 5, "cert_alignment": 3,
               "mentor_ratio": 4, "placement_support": 4, "cost_transparency": 3}

print(score(institute_a))  # 69.0
print(score(institute_b))  # 67.0

The two institutes above are hypothetical, chosen to show a close call. On these weights, A edges out B by two points, mostly because it is lab-heavy.

Why the weights matter more than the ratings

Now change one thing: suppose you know you struggle without hands-on guidance, so you shift weight from labs to mentoring.

WEIGHTS.update({"hands_on_labs": 20, "mentor_ratio": 25})

print(score(institute_a))  # 65.0
print(score(institute_b))  # 71.0

The ranking flipped, and nothing about either institute changed. Only your priorities did. That is the whole point of the exercise: the "best" institute is not a fact about the institute, it is a fact about the match between the institute and you. Any published ranking, including ours, is answering someone else's weights.

How to fill in the ratings honestly

A score is only as good as the evidence behind it, so rate from things you can verify, not from things you were told.

Hands-on labs: ask for the syllabus and count lab sessions against lecture sessions.
Instructor current: check their recent work history, not their five-year-old bio.
Cert alignment: the syllabus should reference the exam's real domains by name.
Mentor ratio: ask for the actual batch size and how many people answer questions, not the marketing number.
Placement support: ask for a specific recent example, a role and a timeline, not a percentage.
Cost transparency: get exam fees and retake costs in writing before you pay.

If an institute will not answer one of these, rate that factor a 0 or 1. Evasion is data.

One limit of any scorecard

A spreadsheet cannot see delivery quality. Two institutes with identical syllabi can teach very differently, so treat the score as a way to shortlist two or three candidates, then sit in on a trial class before you decide. If you are shortlisting specifically in Karachi, what to look for in a top IT training academy there, including the red flags worth walking away from pairs well with this script, since it covers the local details a generic rubric will miss.

*I ran this kind of comparison across the cloud training market in Pakistan and wrote up the full findings, institute by institute, over here: Best Cloud Computing Training Institutes in Pakistan 2025-2026: Comparison.

What weight would you put on hands-on labs versus mentoring? Drop your numbers in the comments and see whose ranking changes. 👇

I Deployed a Model to Production. The ML Part Was the Easy 20%.

Sherdil IT Academy — Thu, 24 Sep 2026 10:53:27 +0000

Training a model that scores well on a validation set takes an afternoon with the right tutorial. Getting that same model to serve real traffic, reliably, without quietly burning through a cloud budget, took me longer than the training did. That gap is not a machine learning problem. It is a cloud engineering checklist, and here is what is actually on it.

Step 1: containerize the model, not the notebook

A notebook is not a deployable artifact. The first real step is packaging inference code into a container with a pinned, minimal dependency set.

# A serving image should be small and boring, not a full training environment
docker build -t model-serve:v1 .
docker run -p 8080:8080 model-serve:v1
curl -X POST localhost:8080/predict -d '{"input": [...]}'

If your image is several gigabytes because it includes the full training toolchain, split it. Training and serving have almost nothing in common as workloads.

Step 2: push it somewhere a scheduler can find it

# Tag and push to a registry your cluster or managed service can pull from
docker tag model-serve:v1 gcr.io/your-project/model-serve:v1
docker push gcr.io/your-project/model-serve:v1

Step 3: deploy with resource limits set on purpose, not left default

This is the step that separates a working demo from a production service. GPU and memory limits are not optional extras.

# GKE example: a deployment with explicit resource requests/limits
kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: model-serve
spec:
  replicas: 2
  template:
    spec:
      containers:
      - name: model-serve
        image: gcr.io/your-project/model-serve:v1
        resources:
          requests: {cpu: "1", memory: "2Gi"}
          limits: {cpu: "2", memory: "4Gi", nvidia.com/gpu: "1"}
EOF

Leave limits unset and one bad request, or one memory leak, can take down every other workload sharing the node. This is the single most common mistake in a first production deployment.

Step 4: put autoscaling on both ends, not just replicas

kubectl autoscale deployment model-serve --min=2 --max=10 --cpu-percent=70

Scaling replicas up under load is the easy half. The harder half is scaling back down aggressively when traffic drops, since idle GPU time is the line item that quietly wrecks a budget. Check your scale-down settings, not just the scale-up ones.

Step 5: monitor latency and cost as one dashboard, not two

# Vertex AI example: check endpoint metrics from the CLI
gcloud ai endpoints describe ENDPOINT_ID --region=us-central1

Watch p99 latency and hourly spend side by side. A model that is fast but expensive and a model that is cheap but slow both fail the same way in production: someone eventually turns them off.

Step 6: have a rollback that takes one command

kubectl rollout undo deployment/model-serve

If rolling back requires a manual process, it will not happen fast enough when it matters. Test the rollback before you need it, not during an incident.

What this list actually is

None of these six steps required a machine learning skill. They required cluster and infrastructure fundamentals applied to a workload that happens to serve a model instead of a web app. That is exactly the gap that is opening up in the market right now: plenty of people can train a model, and a shorter supply of people can be trusted to run one.

If this checklist felt more familiar than the modeling itself, that is worth paying attention to. The roles built around exactly this skill set are growing faster than the general cloud job market right now, and knowing where they actually are matters more than knowing they exist. I mapped out where the current AI-adjacent cloud demand sits in Pakistan, sector by sector, over here: what the cloud computing job market in Pakistan actually looks like right now.

I put the complete picture together, the specific skills that map to each stage of an ML pipeline, realistic salary data for AI-adjacent cloud roles, and where demand is concentrated, over here: AI and Cloud Computing in Pakistan: Why Machine Learning Needs Cloud Engineers.

Which of these six steps have you actually had to debug at 2am? Drop it in the comments. 👇

6 Weeks of Hands-On Azure CLI Labs to Pass the AZ-104

Sherdil IT Academy — Tue, 15 Sep 2026 10:08:31 +0000

The AZ-104 is a performance-based exam. You are clicking through the actual Azure portal and typing real commands under a timer, not answering multiple choice about what a resource group is. Which makes it strange how much AZ-104 prep still consists of watching four-hour video courses and taking notes. Notes do not build the muscle memory the exam is actually testing.

So here is the plan I would run instead: 6 weeks, entirely hands-on, built around the free-tier Azure sandbox and the Azure CLI, mapped directly to the exam's own skill domains.

Before week 1: set up the sandbox

Use a free Azure account or the Microsoft Learn sandbox, not a shared work subscription. You need permission to break things.

az login
az account set --subscription "<your-sub-id>"
az group create --name az104-lab --location eastus

Every week below assumes you are working inside this one resource group, and tearing pieces of it down as you go, which is itself part of the exam's skill set.

Weeks 1-2: Identity and governance

This domain is roughly 20% of the exam and the one people skip in video courses because it feels administrative. It is not administrative on exam day.

# Create a user and assign a role at resource-group scope
az ad user create --display-name "Lab User" --user-principal-name labuser@yourtenant.onmicrosoft.com --password "TempPass123!"
az role assignment create --assignee labuser@yourtenant.onmicrosoft.com --role "Contributor" --resource-group az104-lab

# Apply a resource lock so you cannot accidentally delete the group mid-lab
az lock create --name dont-delete --resource-group az104-lab --lock-type CanNotDelete

By the end of week 2, you should be able to explain the difference between a role assignment at subscription, resource-group, and resource scope without looking it up.

Weeks 3-4: Storage, compute, and networking

The largest single chunk of the exam, and the one that rewards raw repetition.

# Storage: create an account and a container, then lock down public access
az storage account create --name az104labstorage --resource-group az104-lab --sku Standard_LRS
az storage container create --name lab-container --account-name az104labstorage --public-access off

# Compute: spin up a VM and immediately resize it
az vm create --resource-group az104-lab --name lab-vm --image Ubuntu2204 --generate-ssh-keys
az vm resize --resource-group az104-lab --name lab-vm --size Standard_B2s

# Networking: create a VNet and a subnet, then check effective routes
az network vnet create --resource-group az104-lab --name lab-vnet --subnet-name lab-subnet
az network nic show-effective-route-table --resource-group az104-lab --name lab-vmVMNic

Do each of these commands at least three times across the two weeks, changing one parameter each time. The exam rewards fluency, not familiarity.

Weeks 5-6: Monitoring and troubleshooting

The domain most people under-prepare for, because it is the hardest to fake with flashcards.

# Enable diagnostic logging and query it back
az monitor diagnostic-settings create --name lab-diag --resource /subscriptions/<sub-id>/resourceGroups/az104-lab/providers/Microsoft.Compute/virtualMachines/lab-vm --logs '[{"category": "Administrative","enabled": true}]' --storage-account az104labstorage

# Simulate a failure and practice reading it
az vm stop --resource-group az104-lab --name lab-vm
az vm get-instance-view --resource-group az104-lab --name lab-vm --query instanceView.statuses

Deliberately break something in your own sandbox during week 6, a wrong NSG rule, a stopped VM a dependent service expects to be running, and practice diagnosing it from the CLI output alone. That is a closer simulation of exam pressure than any video course gets you.

Tear it all down

az group delete --name az104-lab --yes --no-wait

Do this at the end of every week, not just at the end of the plan. Rebuilding the resource group from scratch each time is itself repetition, and it keeps you from accumulating a messy sandbox that no longer reflects a clean exam-day state.

What this does not replace

A lab plan gets you fluent with the tooling. It does not replace working through the official exam skills outline line by line, or sitting a few timed practice exams in the final week to get used to the two-hour pace. Treat this as the hands-on 80%, not the whole 100%.

I put the complete picture in one place: the current 2026 exam fee in PKR, what a realistic study timeline actually looks like around a full-time job, and the free resources worth using before you pay for anything, over here: Azure AZ-104 Exam Cost & Preparation Guide for Pakistani Professionals.

Once you pass, what does the AZ-104 actually add to your paycheck as an Azure Administrator in Pakistan? Worth knowing before you commit six weeks to this.

Which domain above is the one you'd need to lab the hardest? Drop it in the comments. 👇

The Kubernetes Exam Your Daily kubectl History Already Chose

Sherdil IT Academy — Mon, 31 Aug 2026 07:25:08 +0000

Every syllabus comparison of the CKA and the CKAD tells you the same thing: one is broader, one is narrower, both are two hours, both need 66%, both are 100% hands-on. None of that actually tells you which one to sit. What tells you is far simpler and sitting right there in your shell history: the commands you already run against a cluster every week.

Instead of another domain-by-domain breakdown, run this 5-command self-test. It takes less time than reading a syllabus PDF.

The self-test

Open your shell history (history | grep kubectl, or just think back to last week) and check off which of these five you actually typed, not which ones you know exist.

# 1. Node-level operations
kubectl drain node-3 --ignore-daemonsets
kubectl cordon node-3

# 2. Cluster state backup/restore
etcdctl snapshot save /backup/etcd-snap.db

# 3. Cluster-wide access control
kubectl create rolebinding dev-binding --role=dev-role --user=jane -n team-a

# 4. Rolling out an application change
kubectl set image deployment/api api=myorg/api:v2.3
kubectl rollout status deployment/api

# 5. Application-level debugging
kubectl describe pod api-7d9f8 | grep -A5 Events
kubectl logs api-7d9f8 --previous

Commands 1 through 3 are cluster-owner work: you are responsible for the machine underneath the workloads, not just the workloads. Commands 4 and 5 are the daily reality of shipping and debugging an application on infrastructure someone else keeps running.

Scoring it

If your real, honest history leans 1-2-3, that is a CKA profile. The exam's four domains, cluster architecture, workloads and scheduling, services and networking, and troubleshooting, are all written from the point of view of the person who owns the node, not just the pod running on it.

If your history leans 4-5, that is a CKAD profile. Its domains, application design, deployment configuration, observability, and application environment, assume the cluster is a given and test how fast and correctly you can ship and fix what runs on top of it.

Most engineers do not sit at either extreme. If you are close to even, the tiebreaker is not preference, it is the market: over 80% of Kubernetes job postings in Pakistan in 2026 name the CKA specifically, even for roles that lean closer to application deployment day-to-day. When the self-test is a genuine toss-up, that market data is the deciding vote, not a coin flip.

Why this beats a syllabus comparison

A syllabus tells you what is testable. It does not tell you what is natural. Two engineers can read the identical CKA domain list and one will find etcd restore drills intuitive because they have broken a cluster and fixed it before, while the other will find the same drills exhausting because their daily work never touches that layer. Preparation time roughly triples when you are studying a domain that is not already close to your muscle memory. The self-test above is really a proxy for that: it tells you which exam you can prepare for in 12 weeks without fighting your own instincts the whole way.

The certification is one line item, not the whole plan

Whichever exam the self-test points you to, it is worth remembering that a certification is a single, well-defined credential inside a much longer career arc, not a career plan by itself. If you are mapping out where a Kubernetes credential actually sits relative to the rest of the skill stack, from Linux fundamentals through to a lead or architect title, the complete DevOps Career Guide for Pakistan lays out the full seven-to-ten-year path and exactly where a CKA or CKAD pays off most along it.

I put the full comparison in one place: the 2026 PKR pricing for both exams, role-based recommendations, and the salary premium each certification carries in the Pakistani market, over here: Kubernetes Certification Pakistan: CKA vs CKAD.

Ran the self-test. Which side did your real history land on, and did the exam you sat match it? Drop it in the comments. 👇

A Free 16-Week Cloud and DevOps Syllabus for Karachi (2026)

Sherdil IT Academy — Mon, 17 Aug 2026 08:21:08 +0000

Every free resource you need to go from zero to a genuinely hireable cloud or DevOps skill set already exists, and most of it is free. The problem was never access. The problem is that nobody hands you an order, so people bounce between AWS Skill Builder, random YouTube tutorials, and a Udemy course they never finish, and eight months later they still could not tell you what job they are qualified for.

So here is a fixed syllabus. Sixteen weeks, entirely free resources, no ambiguity about what to do next. Follow it in order.

Weeks 1 to 3: Linux and the command line

Nothing else on this list works without this foundation.

freeCodeCamp's Linux fundamentals content (YouTube) for the core commands, file permissions, and process management
Practice daily in a free-tier virtual machine or WSL, not just by watching

By the end of week 3 you should be comfortable navigating a server with no GUI, editing files in vim or nano, and managing basic services with systemctl.

# Daily practice habit, not optional
ssh into your VM every day, even for ten minutes
systemctl status <any-service>
journalctl -u <any-service> --since today

Weeks 4 to 6: Git and one programming language

freeCodeCamp again, this time for Python or JavaScript fundamentals
Git and GitHub, practiced by committing something daily, not just reading about branches

By week 6 you should have a GitHub profile with actual commit history, not a blank green square.

Weeks 7 to 10: Pick one cloud, go deep

This is the point where people scatter across AWS, Azure, and GCP at once and slow themselves down. Pick one.

AWS Skill Builder (free tier) if you are targeting the widest local hiring base
Google Cloud Skills Boost if your target companies run GCP
Microsoft Learn if you already know you are heading into a bank or an Azure shop

Whichever you pick, do the hands-on labs, not just the reading modules. Deploy something real: a static site, a small API, a database-backed app. Screenshot it working and write a short note on what you built and why.

Weeks 11 to 13: Containers and Kubernetes

KodeKloud's free YouTube content for Docker and Kubernetes fundamentals
TechWorld with Nana for the conceptual explanations that make Kubernetes click
Build a local cluster (Minikube or Kind) and deploy your week 7 to 10 project into it

# Minimum viable proof you understand the basics
kubectl get pods
kubectl describe pod <pod-name>
kubectl logs <pod-name>

By the end of week 13, you should be able to explain what a Pod, a Deployment, and a Service each do, and why you would use one over another.

Weeks 14 to 16: CI/CD and one real end-to-end project

GitHub Actions documentation and examples (free, and the most commonly used CI/CD tool for portfolio projects)
Wire your containerized app from weeks 11 to 13 into a pipeline: commit triggers build, build triggers deploy

This is the single most important project on the whole syllabus. One complete pipeline, end to end, on your GitHub, proves more than every certificate of completion combined.

What this syllabus does not include, on purpose

It does not include every free resource that exists. DigiSkills, NAVTTC, and the other government programs are worth exploring, but they overlap heavily with what is already listed here, and running two curricula at once is how people stall. Pick this syllabus or a government program, not both at the same time.

It also does not end with a certification, deliberately. This sequence builds the skill. What you do with it next, whether that is applying for jobs directly or adding a formal certification like the CKA to make the skill legible to recruiters, is a separate decision. If you finish this syllabus and want the credential that makes 80% of local Kubernetes job postings take you seriously, the full CKA certification prep guide for Pakistani engineers picks up exactly where week 16 leaves off.

The honest timeline

Following this syllabus at a genuine 10 to 12 hours a week, sixteen weeks gets you to a real, demonstrable skill level, not a finished career. Expect another few months of job searching and interview practice after that. It is slower than a paid bootcamp, and it costs nothing but the hours you put in.

This 16-week path is one route through it. I put together the complete list of every genuinely useful free program available in Karachi in 2026, government and vendor programs included, along with honest notes on where each one is weak, over here: "free IT courses in Karachi".

Where are you on this syllabus right now, and which phase has taken longer than you expected? Drop it in the comments. 👇

7 Questions to Ask Before Paying for an IT Course in Karachi

Sherdil IT Academy — Mon, 03 Aug 2026 07:18:20 +0000

Karachi does not have a shortage of IT courses. It has a shortage of good ones, buried inside a much larger pile of institutes selling outdated slide decks at bootcamp prices. With fees running anywhere from PKR 40,000 to 180,000 depending on the specialization, picking wrong is not a small mistake. It is months of time and real money.

I get asked "which institute should I join" often enough that I built a fixed checklist. It is not about brand names. It is seven questions that expose the difference between a course built for outcomes and a course built to fill seats.

1. Who is teaching, and are they still doing the work?

Ask for the instructor's current job title, not their job title from five years ago. Cloud, DevOps, and security move fast, and an instructor who has not touched a production system recently is teaching from memory, not from practice. A quick LinkedIn check settles this in two minutes.

2. Is the curriculum hands-on or slide-based?

Ask what percentage of class time is lab work versus lecture. For technical fields like AWS, Kubernetes, or cloud security, anything below 60 percent hands-on is a red flag. You are not paying to watch slides; you can get slides for free. You are paying for guided practice on real environments with someone there to unblock you when something breaks.

3. What do graduates actually build?

Ask to see finished student projects, not marketing testimonials. A real program produces a portfolio: a deployed app, a hardened cluster, a CI/CD pipeline someone can point to in an interview. If the institute cannot show you specific student work, they likely are not producing it.

4. Does the fee include the certification exam?

Certification vouchers (AWS, CKA, AZ-500) cost real money on top of the course itself. Some providers bundle the exam fee; many do not, and only mention that after you have paid. Get this in writing before you enroll, because it can add tens of thousands of rupees to what looked like a fixed price.

5. Is there any placement or interview support?

A course that ends the day the class ends is teaching, not career support. Ask specifically what happens after: mock interviews, resume review, referrals, or a portfolio review session. Programs that treat placement as part of the product, not an afterthought, tend to be run by people who actually track outcomes.

6. What is the batch size, and who answers questions?

A 60-person batch with one instructor means you are mostly on your own. Ask the actual student-to-mentor ratio, not the marketing number. This single detail predicts more about your experience than almost anything else on this list.

7. Can they show you a hiring outcome, specifically?

Not "our students get placed." Ask for a specific example: a name, a company, a rough timeline from course completion to offer. Vague claims are cheap to make. Specific, checkable ones are not.

Reading the answers together

No single answer disqualifies a provider on its own. But if you ask all seven and get vague or dodged answers on more than two or three, that is your answer. The Karachi IT training market has genuinely strong providers in it. It also has a lot of noise. This checklist is how you tell them apart before you pay, not after.

Where this actually leads

The reason to be this careful is that the destination is real. Cloud, DevOps, and especially cloud security remain some of the most underserved technical niches in Pakistan's job market right now, and the pay gap between a well-trained engineer and a self-taught one closes fast once you can prove hands-on skill. If security is the direction you are weighing, it is worth understanding [what the cloud security career path actually looks like in Pakistan][INTERNAL] before you pick a course, since the right training decision depends on which of those roles you are actually aiming for.

*I put the full picture together in one place: fee ranges by specialization, the specific in-demand courses for 2026, and a deeper breakdown of free versus paid options, over here: IT courses in Karachi for 2026.

Which of these seven questions have you never thought to ask before enrolling somewhere? Drop it in the comments. 👇

The Cloud Engineer Salary Negotiation Playbook (Pakistan, 2026)

Sherdil IT Academy — Thu, 02 Jul 2026 10:10:56 +0000

Most cloud engineers in Pakistan lose the salary negotiation before it starts, and not because their skills are weak. They lose it because they treat the offer as a fixed number instead of a set of levers. The recruiter says a figure, the engineer says "okay," and thousands of rupees a month quietly disappear.

This is the practical playbook I wish someone had handed me earlier: the numbers to anchor to, the levers that still move after the base is "locked," and the exact lines to say. No theory, no motivation. Just the mechanics.

Step 1: Anchor to the market, not your last payslip

The single most expensive mistake is anchoring your ask to your current salary. Employers love it when you do, because a 20 percent bump on a low base is still a low base. Anchor to what the role pays in 2026 instead.

Level	Monthly base (PKR)	Remote (USD/mo)
Junior cloud engineer	60,000 to 130,000	800 to 1,500
Mid-level cloud/DevOps	130,000 to 280,000	1,500 to 3,000
Senior / platform	280,000 to 550,000	3,000 to 6,000

Walk in with a range, state the top of it first, and back it with evidence: certifications, a GitHub portfolio, and specific things you have shipped. When you name a number, stop talking. Silence is a tool, not a gap you need to fill.

Step 2: Know your levers before the call

"The base is fixed" is almost never the end of the conversation. It just means the money moved somewhere else. Here is the full menu of what is actually negotiable, roughly in order of how often it works:

Signing bonus. One-time cost, off the recurring payroll line, so approvals are easier.
Performance review at 3 to 6 months with a pre-agreed raise band written into the offer.
Remote or hybrid days, which is real money once you price in commute and time.
Certification and training budget (AWS, CKA, Terraform). Ask them to pay the exam fees.
Annual leave and flexible hours.
Title. A better title compounds into every future offer you ever get.
Equipment allowance for a laptop and a home-office setup.

The point: if you only negotiate base, you are playing one square on a board that has eight.

Step 3: The scripts

You do not need to be aggressive. You need to be specific and calm. Here are lines you can adapt word for word.

When they ask your expected salary first:

"Based on the market range for this role and my experience with [AWS, Kubernetes, Terraform], I am targeting PKR [top of your range]. I am open to discussing how we structure that."

When they say the base is fixed:

"I understand the base is set. In that case, can we look at a signing bonus and a documented performance review at six months? If the base cannot move now, I would like a clear path for it to move soon."

When they lowball you:

"That is below what I have seen for this scope of work in 2026. Help me understand what is driving the number, and let us see where there is room, whether that is base, bonus, or review timing."

When you already have another offer:

"I have another offer on the table, and I would genuinely prefer to work here. If we can close the gap on [base / bonus / remote days], I am ready to sign."

Never invent a competing offer you do not have. It is easy to get caught, and it ends the relationship. If you have one, use it plainly. If you do not, lean on the market data instead.

Step 4: Do the total-comp math

Two offers with the same base are rarely equal. Compare the whole package, not the headline number.

Lever	Offer A	Offer B
Monthly base	200,000	190,000
Signing bonus	0	150,000
Remote days/week	0	3
Cert budget	0	100,000/yr
6-month review	No	Yes

Offer B has the lower base and is clearly the stronger deal once you add the bonus, the saved commute, and the funded certifications. This is exactly the math most engineers skip, and it is where quiet money hides.

Step 5: Get it in writing

A verbal "we will sort the raise out later" is worth nothing. Once you agree on the terms, ask for the offer letter to state the base, the bonus, the review date, and the raise band. If it is not written, it did not happen. Polite, firm, and documented wins every time.

The mindset shift

Negotiating is not being difficult. Every good manager expects it, and many quietly respect the engineers who do it well because it signals you will advocate for the team and the budget too. The engineers who stay underpaid in Pakistan are almost never the least skilled. They are the ones who never ran the play.

I put the full framework, including the complete lever checklist, more scripts for tricky moments, and the total-comp calculator, into a Pakistan-specific guide over here: how to negotiate a cloud engineer salary in Pakistan.

What is the one lever you have never tried to negotiate: bonus, review timing, or remote days? Drop it in the comments. 👇

The Cloud Security Toolchain Every Engineer Should Know (2026)

Sherdil IT Academy — Sat, 27 Jun 2026 11:09:58 +0000

Cloud security interviews don't reward people who can define the shared-responsibility model. They reward people who've actually run the tools. So instead of theory, here's the practical toolchain I'd expect a working cloud security engineer to be comfortable with in 2026 - grouped by where it sits in the pipeline.

(Quick note on why this skill set is worth building: in markets like Pakistan, cloud security is currently the most underserved technical niche - regulators are forcing banks and fintechs to staff it, and the salary premium reflects how few people can actually do the work.)

1. Catch misconfigurations before they ship (IaC scanning)

Most cloud breaches start as a misconfiguration in a Terraform file, not a zero-day. Scan infrastructure-as-code in CI before it ever reaches an account:

Checkov
tfsec
Terrascan

# Scan a Terraform directory with Checkov
checkov -d ./infra

# Scan the same directory with tfsec
tfsec ./infra

Wire one of these into your pipeline so a misconfigured security group fails the build instead of reaching production.

2. Secure the containers and the cluster

Two different jobs here: scanning images for known vulnerabilities, and watching runtime behaviour.

Image scanning - Trivy, Snyk:

# Scan a container image for vulnerabilities
trivy image myorg/payments-api:latest

Runtime threat detection — Falco watches for suspicious syscalls inside running containers (a shell spawned in a container, unexpected writes to sensitive paths, etc.).

Kubernetes hardening is its own competency: RBAC done properly, PodSecurityAdmission, and NetworkPolicies to stop flat east-west traffic. If everything in your cluster can talk to everything else, you don't have segmentation — you have a single blast radius.

3. Stop hardcoding secrets

Secrets in env files and Git history are still one of the most common findings. Manage them properly:

HashiCorp Vault for dynamic secrets and central policy
Kubernetes Secrets with encryption at rest enabled (it isn't on by default in every setup - check)

4. Use the cloud's native detection (it's already there)

Each major cloud ships strong detection tooling that teams routinely leave half-configured:

AWS - GuardDuty, Security Hub, Macie, CloudTrail, Config
Azure - Defender for Cloud, Sentinel, Azure Monitor
GCP - Security Command Center

Knowing how to turn these on, tune the noise, and route findings somewhere a human will see them is a genuinely marketable skill.

5. The non-tool skill that ties it together: IAM

Every item above sits on top of identity. If your IAM policies are sloppy - wildcards everywhere, long-lived keys, no least-privilege - no scanner saves you. Designing tight IAM policies and understanding the shared-responsibility model is the core competency hiring managers probe hardest, because it's the one you can't fake with a dashboard.

Where this leads (the part that pays)

Put this toolchain together with real hands-on practice and you're qualified for roles that are, frankly, underfilled. Typical 2026 ranges in the Pakistani market:

Role	PKR/month	Remote (USD)
Cloud Security Engineer	150,000-320,000	$1,500-$3,000
DevSecOps Engineer	180,000-380,000	$2,000-$3,800
Cloud Security Architect	350,000-700,000	$3,500-$6,000

The fastest way in, if you already have 1-2 years of cloud/DevOps experience, is about 4–8 months of focused work on exactly the tools above - and it tends to lift your salary 25-40%. Build a GitHub portfolio with real security scenarios; that beats any certificate on its own.

I wrote a full, Pakistan-specific career breakdown - all seven cloud-security role types, the certification order and costs, and the three entry paths - over here: Cloud Security Careers in Pakistan.

Which of these tools is already in your pipeline, and which one are you avoiding? Drop it in the comments. 👇

How I'd Pass the CKA in 12 Weeks (Performance-Based, No Multiple Choice)

Sherdil IT Academy — Tue, 09 Jun 2026 12:16:17 +0000

The Certified Kubernetes Administrator (CKA) is not a multiple-choice exam, and that single fact changes everything about how you should prepare for it. There's no bluffing, no "process of elimination," no memorizing a question bank. You get 2 hours, 15–20 tasks, and a live Kubernetes cluster, and you need 66% to pass.

If you're a DevOps or platform engineer sitting this exam, here's the 12-week, lab-first plan I'd follow — plus the exam-day setup that quietly saves you the most time.

What you're actually walking into

The domains are weighted, and the weighting tells you exactly where to spend your hours:

Domain	Weight
Troubleshooting	30%
Cluster Architecture & Installation	25%
Services & Networking	20%
Workloads & Scheduling	15%
Storage	10%

Troubleshooting is the highest-weighted domain at 30% — and it's the one most candidates underestimate. You can't grind it with flashcards; you have to break clusters and fix them until CrashLoopBackOff, NodeNotReady, and broken DNS stop scaring you.

The exam costs $395 (~PKR 110,600) and includes one free retake within 12 months. It tests your ability to work efficiently with the docs, not to memorize every YAML field — but the clock is real.

The 12-week, lab-first plan

Target ~180–200 hours total: 2–3 hours on weekdays, 5–6 on weekends. The ratio that matters most: 20% concept review, 80% hands-on labs.

Weeks	Focus	Lab goal
1–2	Core architecture: Pods, ReplicaSets, Deployments, Namespaces, kubectl	Deploy 10+ apps via CLI only
3–4	Workloads & scheduling: limits, taints/tolerations, affinity, DaemonSets, CronJobs	Schedule pods on specific nodes; set resource quotas
5–6	Services & networking: ClusterIP, NodePort, LoadBalancer, Ingress, NetworkPolicies, CoreDNS	Configure Ingress with TLS; write a NetworkPolicy
7–8	Storage: PVs, PVCs, StorageClasses, access modes	Provision storage for a stateful app; resize a PVC
9–10	Cluster architecture: kubeadm init/join, RBAC, etcd backup/restore, certs	Build a multi-node cluster; back up and restore etcd
11	Troubleshooting: NotReady nodes, CrashLoopBackOff, DNS, apiserver failures	2 Killer.sh exams, target 70%+ each
12	Full timed simulation across all domains	2 Killer.sh + 1 KodeKloud mock

The resources that are actually worth it

Non-negotiable:

KodeKloud CKA course + labs — the best structured prep available. Pro is ~$16/mo; two months is enough.
Killer.sh simulator — two free full-length sessions come with your exam registration. It's harder than the real thing on purpose. Widely regarded as the most accurate simulation.
Official Kubernetes docs (kubernetes.io/docs) — allowed during the exam, but you won't have time to read pages end-to-end. Practice navigating them fast.

Skip: brain-dump sites, video-only prep with no labs, and theory without timed practice.

Exam-day setup (do this in the first 2 minutes)

Before touching a single task, configure your environment. These shortcuts pay for themselves many times over:

# Alias kubectl -> k
alias k=kubectl

# Dry-run template generator
export do='--dry-run=client -o yaml'

# Now you can scaffold YAML instead of typing it by hand:
k create deployment web --image=nginx $do > web.yaml

And set up vim for clean YAML editing:

" ~/.vimrc
set expandtab
set tabstop=2
set shiftwidth=2

The single most expensive mistake people make: forgetting to switch cluster context. Every question specifies its cluster. Do this first, every time:

kubectl config use-context <cluster-name>

Then work the exam strategically:

Read all tasks first (~3–4 minutes) and prioritise by weight.
Generate YAML with --dry-run=client -o yaml instead of writing it from scratch.
Flag and skip anything you get stuck on — come back later.
Verify before moving on: kubectl get, kubectl describe, kubectl logs.

One Pakistan-specific note: book a Pearson VUE test centre if you can. Remote proctoring needs a stable 5 Mbps+ line, a webcam, and a clean private room — test your home connection at your exam time a few days ahead, and have a different-carrier mobile hotspot as backup.

Is it worth the PKR 110,600?

For the Pakistani market in 2026, yes — the salary data is hard to argue with:

Role	Without CKA	With CKA	Uplift
DevOps (mid)	PKR 120–180K	PKR 180–280K	30–40%
Platform/K8s (mid)	PKR 200–320K	PKR 320–550K	40–50%
Platform/K8s (senior)	PKR 350–500K	PKR 500–800K	25–30%

And the remote ceiling is higher still: a CKA-certified engineer with 3–4 years of hands-on Kubernetes can realistically target $2,000–$3,500/month remote — roughly PKR 700,000/month at $2,500. Plenty of engineers have some Kubernetes experience; far fewer have the breadth the CKA forces you to build.

The honest prerequisite check

Don't book it yet if you have no Linux command-line comfort or zero hands-on infrastructure exposure — the CKA assumes both. If you're a pure app developer with no infra interest, look at the CKAD instead. But if you've got 1–2 years of Docker/CI-CD/Linux under your belt, 12 disciplined weeks is enough.

I wrote a full, Pakistan-specific breakdown of this — payment methods that work with local cards, a deeper resource tier list, and the complete week-by-week labs — over here: the complete CKA certification guide for Pakistani engineers".

What tripped you up most in your CKA prep — troubleshooting speed, or just finishing in time? Drop it in the comments. 👇