DEV Community: Arek

Tips for passing CKAD exam at 1st attempt (2026 Edition)

Arek — Tue, 28 Apr 2026 20:53:15 +0000

How it all started

Last year we got news: our new client would be using Kubernetes extensively. I was both excited and scared, as I had only limited exposure to Docker in a professional setting, and K8s is the next level.

After doing some research, I had a chat with my boss which resulted in funding for both the KodeKloud platform and two attempts at the CKAD exam (we lucked out by buying the exam at half price during Cyber Week). That started the long process of learning Kubernetes from scratch under the guidance of Mumshad Mannambeth and his excellent CKAD course.

CKAD Exam Structure

The exam consists of ~20 practical tasks that you need to solve in 120 minutes. You are supervised by a proctor throughout the process.

As of 2026, you are required to use the PSI Secure Browser. This app monitors your system, kills unauthorized processes, and requires full access to your camera and microphone.

Important changes compared to previous years:

Copy-Paste: Past exams used a browser extension that made copy-pasting clunky. Now, it's seamless using either Ctrl+C / Ctrl+V or Ctrl+Shift+C / Ctrl+Shift+V.

Context Switching: While KodeKloud tests still use a simple context switch, both Killer.sh and the actual exam often require you to ssh into different nodes.

Aliases: In the past, people recommended setting up complex aliases like export do="--dry-run=client -o yaml". Now, because you frequently switch sessions via SSH, these aliases don't persist unless you re-apply them. The only pre-configured alias is k for kubectl.

The Ingress vs. Gateway API Situation

Around the turn of 2025/2026, the Gateway API became the new standard, and the traditional Nginx Ingress Controller was deprecated in many environments.

However, don't let that fool you! In my actual exam (April 2026), I had two tasks regarding Ingress and zero tasks regarding Gateway API. This shows that the curriculum still leans heavily on Ingress.

My advice: Be prepared for both. Mastering Gateway API is important for the future, but for the sake of the exam, make sure you can still write a classic Ingress YAML in your sleep.

Credly

Passing the exam results in a PDF certificate that verifies your skills. You can also showcase your achievement with a digital badge on Credly:

Navigating the Documentation

During the exam, you are allowed to use the official Kubernetes documentation, API docs, and discussion threads. This is crucial for copying YAML snippets that cannot be easily generated via imperative commands.

Resource	Strategy
Network Policy	Copy YAML (hard to memorize)
Persistent Volumes	Copy YAML (use `Ctrl+F` for "kind: PersistentVolume")
Probes	Memorize syntax or quick copy
Env Vars (Secrets/CM)	Memorize `env`, `envFrom`, `valueFrom` to save time
Ingress	Copy YAML
Resources/Limits	Memorize (simple syntax)
Init & Sidecars	Memorize (note: Native Sidecars use `restartPolicy: Always`)
SecurityContext	Better to memorize (can be tricky to find quickly)
CronJob	Use docs if you forget the cron schedule format

TIP: Before the exam, click through each resource in the docs to familiarize yourself with their location. Scrolling in the PSI browser can be painfully slow, so get used to using Ctrl+F.

The Learning Curve

The start of the course was the hardest part—grasping the depth of the Kubernetes ecosystem. Understanding the theory behind cluster components and dependencies was time-consuming but essential for context.

The Middle Section (Core Concepts to Kustomize) was the most useful.

Go Imperative: From day one, study imperative commands. You need to create pods, deployments, and services as fast as possible. k run, k create, and k expose are your best friends.
YAML Mastery: Learn to tweak resources quickly using k apply -f <filename>.
The Details: Remember the subtle differences, like port vs. targetPort vs. nodePort, or how Native Sidecars are now handled within the initContainers field.

The Final Stretch:
Don't skip the mock exams. I highly recommend the KodeKloud Mock Exam Series. They can be frustrating because a minor typo results in a zero score, but they keep you humble and precise. After these, I tackled Killer.sh, scoring 66/113 on my first try without rushing. It gave me the confidence I needed.

How long does it take?

I started with zero K8s knowledge in November 2025 and passed on April 24th, 2026. This included a 2-month break, followed by a final month of "crunching" the material.

Prepare yourself for around 4 months of learning at a steady pace, or faster if you are already familiar with some Kubernetes concepts.

My take? Don't over-test yourself. I was ready sooner than I thought. At some point, doing too many mock tests with rigid grading can actually degrade your confidence. If you find yourself stuck on minor caveats, step back, review the fundamentals, and then hit a Killer.sh session. If you can handle that environment, you are ready for the real thing.

Useful Links

Official CKAD Curriculum (GitHub) - Check what is actually on the exam.
Kubernetes Documentation - Your only allowed friend during the test.
Killer.sh - The best exam simulator (usually harder than the real thing!).
KodeKloud CKAD Course - My primary learning resource.
KodeKloud CKAD Mock exams - Mock tests to learn how to work under pressure of time.

How to make splash screen with progress tracking in Angular?

Arek — Sun, 08 Jun 2025 20:18:18 +0000

📝 Preface

Loading all initialization data in an Angular application can sometimes take a while—especially over slow internet connections. Displaying a blank screen during this time can lead to a poor user experience.

To mitigate this, we can introduce a splash (or loading) screen to provide users with immediate visual feedback, making the app feel more responsive and polished.

🧪 Demo Project

The demo below showcases a working implementation of a splash screen:

⚡ Try this code on StackBlitz or GitHub

Should the Splash Screen Be a Component?

Short answer: ❌ no.

Here's why:

Angular components aren’t rendered until after the framework bootstraps. This means any splash screen defined as a component would appear too late to be useful.
Initialization tasks like HTTP requests should be handled in provideAppInitializer, before Angular even begins rendering the UI.

File: app/app.config.ts

⚡ View on StackBlitz

    provideAppInitializer(async () => {
      const initializers: AsyncInitializer[] = [
        inject(ConfigLoaderService),
        inject(ConnectionCheckerService),
        inject(StorageInitializerService),
        inject(TranslationLoaderService),
      ];

      for (const initializer of initializers) {
        await performAsyncInitialization(initializer);
      }

      await splashFadeOut();
    }),

For demonstration purposes, performAsyncInitialization() simulates a delay by waiting one second.

The splashFadeOut() function starts the fade-out animation and waits for it to complete.

🎨 Where Should Splash Screen Styles and Scripts Go?

You can embed splash screen styles and scripts directly inside the <app-root> tag in index.html. This ensures they appear instantly and can be easily removed once the app is initialized, leaving no residue behind.

File: index.html

⚡ View on StackBlitz

<app-root>
  <!-- START Splash screen -->

  <!-- Styles -->
  <style>
    [...]
  </style>

  <!-- Content -->
  <div class="splash-container" id="splash">
    <div class="circle-outline"></div>
    <svg>
      [...]
    </svg>
    <div class="loading-text">
      <span id="updater">Loading Angular app</span>
      <span class="jumping-dots">
        <span class="dot"></span>
        <span class="dot"></span>
        <span class="dot"></span>
      </span>
    </div>
  </div>

  <!-- Place for scripts -->

  <!-- END Splash screen -->
</app-root>

If the splash screen code is large, consider moving styles and scripts into external files for better maintainability. However, this introduces a trade-off: additional HTTP requests will slightly delay the splash screen's appearance. Also, these files must reside in the public folder, increasing the final build size.

🔄 Can I Update the Splash Screen Dynamically?

Yes, you can dynamically modify the splash screen—for example, to show real-time progress updates.

To do this, reference a DOM element by its id and update its content during app initialization. Be mindful: both the HTML and Angular logic must reference the same id, so consistency is key.

File: index.html

⚡ View on StackBlitz

<span id="updater">Loading Angular app</span>

File: app/core/utils/splash-screen.utils.ts

⚡ View on StackBlitz

export function updateTitle(text: string): void {
  const elem = document.getElementById('updater');
  if (elem) {
    elem.textContent = text;
  }
}

📌 Bottom line

Splash screens in Angular are not only possible—they're practical.
Since Angular lacks a built-in solution, a custom inline approach is the most efficient and reliable.
Keep splash logic minimal and inline, and ensure it is removed cleanly once the app is initialized.

🕒 What's Next (Advanced Topics)

To elevate this implementation and make it suitable for production-grade apps, here are some advanced areas worth exploring:

⚡ Optimize Splash Screen Load Time After First Load
Cache initialization data (e.g. app config, feature flags) using LocalStorage or IndexedDB, so it can be reused without delay.
🛠️ Integrate with Service Worker for Offline & Fast Loads
Ensure splash screen assets (HTML, images, inline styles) are cached by your Angular Service Worker.