DEV Community: ExamCert.App

How Hard Is 350-901 DEVCOR? I Failed It Once, and the Reason Was Embarrassing

ExamCert.App — Thu, 20 Aug 2026 15:12:14 +0000

Every thread asking how hard is 350-901 gets the same two replies: "it's a professional-level Cisco exam, so hard" and "easy if you're a real developer." Both are useless, and the second one is what got me.

I write software for a living. I assumed DEVCOR would be a formality with some Cisco product names sprinkled on top. I failed, and the post-mortem was uncomfortable enough to be worth writing down.

The exam, factually

90–110 questions, roughly 120 minutes
Multiple choice, multiple response, drag-and-drop, and scenario items
$400 USD
Scaled cut score — Cisco does not publish the pass mark, so there's no "I need 72%" target to aim at
It's a concentration exam for CCNP DevNet / DevNet Professional, paired with the 350-901 core

Check Cisco's current exam topics page before you build a plan — Cisco revises blueprints and the topic list is the contract.

The unpublished cut score matters psychologically. You cannot calculate a safe margin, so the only sane strategy is to be comfortably strong across every topic area rather than banking on carrying a weak domain.

Where I actually lost it

I studied the APIs and ignored the platforms.

Here's the trap for developers. You look at the blueprint, see "software development and design," "using APIs," "application deployment and security," "infrastructure and automation," "network fundamentals," and you think: I know REST, I know OAuth, I know Docker, I know CI/CD, I know Git. This is my home turf.

And it is — for maybe 60% of the exam. The rest is Cisco-platform-specific, and it is not guessable from first principles. Knowing REST does not tell you the shape of a Meraki Dashboard API response, or how a Webex Bot registers a webhook, or what a DNA Center intent API path looks like, or the difference between a NETCONF and a RESTCONF interaction against IOS-XE, or where YANG models fit, or what pyATS is for.

Those questions aren't hard. They're just unlearnable by inference. You either read the docs and touched the sandboxes or you didn't. I hadn't, and I burned a $400 attempt discovering it.

The second thing I got wrong: "design" is a scored skill here

A meaningful chunk of DEVCOR is software design judgment, not code:

When do you pick a message queue over a synchronous call?
Which failure mode does a circuit breaker protect against, and which does a retry with exponential backoff protect against?
How do you make an operation idempotent, and why does that matter for network automation specifically?
Where do secrets live in a pipeline, and what's wrong with the obvious answer?
Twelve-factor principles, applied to an app that talks to network devices
Sequence and architecture diagrams — you'll be asked to read one and identify the flaw

Developers with strong practical habits but no vocabulary for them lose points here, because the questions test the name of the pattern as much as the instinct.

Where it's genuinely hard, ranked

Hardest: breadth. Not depth. No single topic is brutal, but the surface area spans application design, security, deployment models, multiple Cisco platform APIs, network fundamentals, and automation tooling. You can't cram breadth in a week.

Second: unfamiliar-platform questions under time pressure. ~110 questions in 120 minutes is about 65 seconds each. If three consecutive questions are on a platform you skimmed, you lose time and confidence.

Third: the scenario items. Long stems, code snippets, and answers that differ by one detail. Careless reading is expensive.

Not actually hard: the pure programming content. If you ship code, the Python, the Git, the REST, and the containers are the easy marks.

The plan that worked the second time

Weeks 1–2: live in the Cisco DevNet sandboxes. They're free. Get a token, make real calls against Meraki, Webex, DNA Center, IOS-XE RESTCONF, and NX-OS. Write throwaway scripts. The goal isn't mastery — it's that no platform in the exam is a stranger. This single change is most of the difference between my two attempts.

Week 3: design vocabulary. Go through the blueprint's design topics and, for each pattern, write two lines: what problem it solves and what it costs. Circuit breaker, bulkhead, retry/backoff, idempotency, event-driven versus request-response, blue/green versus canary, secrets management. If you can't state the trade-off, you don't know it well enough for the exam.

Week 4: security and deployment. OAuth flows in detail (which grant type, and why — this comes up), token handling, encrypting data in transit and at rest, container security basics, pipeline security. Then CI/CD models and deployment strategies.

Week 5: timed reps. This is where you find the topic areas that quietly rotted. I ran free 350-901 practice questions in timed blocks and kept a single text file of every miss with one line on why. By the end that file had about eleven recurring themes — that's the real study list, and it's much shorter than the blueprint.

Week 6: re-read the blueprint line by line and rate yourself 1–5 on each bullet. Anything under 4 gets an evening. Then book it.

Is it worth $400?

If you're a network engineer moving into automation: yes, unreservedly. DEVCOR forces you to learn software engineering properly rather than accumulating scripts, and that's the transition that changes your salary band.

If you're a developer with no network context: it's worth it only if you work near networking. Otherwise you're paying $400 to prove you can write Python, which your GitHub already does for free.

If you're chasing CCNP DevNet: it's the core exam, so the question is moot — but budget six weeks, not two.

The one-sentence answer

350-901 is hard in proportion to how much Cisco platform surface you've genuinely touched, and easy in proportion to how much software you genuinely write — and most candidates are strong on exactly one of those two axes, which is why the failure stories all sound like mine.

Topic breakdown, current cost, and free practice questions: ExamCert's 350-901 page.

Go make real API calls. That's the whole tip.

CKAD Exam Prep 2026: The 8 kubectl Patterns That Are Worth More Than Any Course

ExamCert.App — Wed, 19 Aug 2026 15:11:56 +0000

Most CKAD exam prep 2026 advice is a reading list. Here's a different take: the exam is two hours, roughly 15–20 hands-on tasks on a live cluster, and the difference between passing and failing is almost entirely how fast you can produce correct YAML.

So this post is eight patterns. Not concepts — patterns. The literal things I typed over and over until they were reflexes. If you internalise these, most of the exam becomes typing practice.

First, the shape of the thing

The current CKAD domains and weights:

Domain	Weight
Application Design and Build	20%
Application Deployment	20%
Application Observability and Maintenance	15%
Application Environment, Configuration and Security	25%
Services and Networking	20%

Passing is 66%. Two hours. You get a free retake within 12 months, and one browser terminal with access to kubernetes.io docs.

Note that Environment, Configuration and Security is the heaviest block at 25% — ConfigMaps, Secrets, SecurityContext, ServiceAccounts, resource requests/limits, and CRDs. People over-prepare Deployments and under-prepare this. Don't.

The 8 patterns

1. Never write YAML from scratch

kubectl create deployment web --image=nginx --replicas=3 --dry-run=client -o yaml > d.yaml

Every single object has a generator or can be scaffolded this way. If you find yourself typing apiVersion: by hand, you've already lost 90 seconds. Learn which resources have kubectl create support (deployment, job, cronjob, configmap, secret, service, serviceaccount, role, rolebinding, quota, ingress) and use run for pods:

kubectl run tester --image=busybox --restart=Never --dry-run=client -o yaml -- sleep 3600 > p.yaml

2. Set your environment in the first 60 seconds

alias k=kubectl
export do="--dry-run=client -o yaml"
export now="--force --grace-period=0"
source <(kubectl completion bash)

Then k create deploy web --image=nginx $do > d.yaml. That $do variable saves you a genuinely material amount of typing across 18 tasks.

3. Always confirm the namespace

Every task tells you a namespace. Half of all "I did it right and got zero" stories are people who created the object in default.

k config set-context --current --namespace=<ns>

Do it at the start of every task. Not once — every task.

4. Patch, don't rewrite

For "add a liveness probe to this existing deployment" style tasks:

k edit deploy web

or for something scriptable:

k set image deploy/web nginx=nginx:1.25
k set env deploy/web KEY=value
k scale deploy/web --replicas=5
k rollout undo deploy/web

kubectl set and kubectl rollout cover a surprising share of the Deployment domain without touching a file.

5. Know the four ways config reaches a container

This is the 25% domain in one bullet list, and you must be fluent in all four:

env.valueFrom.configMapKeyRef — one key as one variable
envFrom.configMapRef — every key as variables
volumes.configMap + volumeMounts — keys as files
the same three again, with secretKeyRef / secretRef / volumes.secret

Write all four out from memory once a day for a week. That's it, that's the drill.

6. Multi-container patterns, by name

Sidecar, ambassador, adapter, and init containers. The exam describes a scenario and expects you to pick the shape. The most common real task: "add an init container that waits for a service" or "add a sidecar that tails a log file from a shared emptyDir." Practise the shared-emptyDir pattern specifically — it's the most frequently asked and the most fiddly to type.

7. Debug in a fixed order

k get po -o wide
k describe po <name>      # events at the bottom — read these first
k logs <name> -c <container>
k logs <name> --previous  # for CrashLoopBackOff
k exec -it <name> -- sh

describe events before logs. Always. Most failures (ImagePullBackOff, failed mounts, unschedulable, failed probes) are diagnosed from events alone in five seconds, and people waste minutes reading logs that never got written.

8. Jobs, CronJobs, and the fields that get asked

completions, parallelism, backoffLimit, activeDeadlineSeconds for Jobs. schedule, concurrencyPolicy, startingDeadlineSeconds for CronJobs. These are pure memorisation and they are reliably worth marks.

The time strategy that actually matters

Two hours, ~18 tasks, each weighted differently — and the weight is shown. Here's the plan:

First pass, 70 minutes. Do every task you can finish in under four minutes. Skip anything that smells long. Flag it and move.
Second pass, 40 minutes. The flagged high-weight ones.
Last 10 minutes. Verify. k get all -n <ns> for each namespace you touched.

The single most common failure mode is spending 20 minutes on one 4% task while three 7% tasks sit untouched. Watch the weights.

Where practice questions fit into a hands-on exam

CKAD is performance-based, so "practice tests" sound irrelevant. They're not — they fix a different problem. Scenario labs fix your sequence. Question sets fix your recall: which field, which apiVersion, which flag.

I did a free CKAD practice test on my commute — twenty questions, no cluster needed — and then hands-on labs at night. The commute sets are what stopped me hesitating on field names, and hesitation is the whole enemy here. The CKAD exam page has the current domain weightings if you want the reference.

A four-week ramp

Week 1: Pods, Deployments, Jobs, CronJobs. Generate everything with $do. No copy-paste from docs.

Week 2: ConfigMaps, Secrets, SecurityContext, ServiceAccounts, resource requests and limits. The heavy domain — give it the most time.

Week 3: Services, Ingress, NetworkPolicy, probes, and multi-container patterns.

Week 4: Timed full simulations only. Two hours, no pausing. Then review — and re-type the ones you got wrong rather than reading the solution.

One opinion to close on

CKAD is easier than CKA. Smaller surface, friendlier tasks, no cluster upgrades or etcd backups. If you're choosing between them and you write applications rather than run clusters, start here.

But it punishes slow typing in a way no multiple-choice exam ever will. Build the reflexes, not the vocabulary.

Microsoft Azure Virtual Desktop Specialty Exam Prep 2026: A Hands-On Engineer's Path Through AZ-140

ExamCert.App — Tue, 18 Aug 2026 15:11:09 +0000

AZ-140 is the quiet one. It doesn't get the traffic AZ-104 or AZ-305 get, and that's exactly why it's worth your time — the people who hold it tend to get called about jobs, because the supply is thin and every enterprise that ran a VDI project in the last five years needs someone who understands it.

This is the Microsoft Azure Virtual Desktop Specialty exam prep 2026 guide I'd hand a colleague: what's on it, what to build, and where people lose marks.

The shape of AZ-140

Roughly 40–60 questions, 100–120 minutes
$165 USD in most regions
Pass at 700/1000
Includes a case study section — multiple questions against one long scenario, and you can't go back once you leave it
Assumes you already know Azure fundamentals: identity, networking, storage, RBAC

That last point is the real prerequisite. AZ-140 is not a beginner exam wearing a specialist badge. It assumes AZ-104-level competence and then tests AVD on top. If you can't explain the difference between Entra ID, Entra Domain Services, and AD DS on an IaaS VM, start there — that distinction alone is worth several questions.

The four skill areas

1. Plan and implement an AVD infrastructure

Host pools first, because everything else hangs off them:

Pooled vs personal. Pooled = many users share session hosts, breadth-first or depth-first load balancing, needs FSLogix. Personal = one user, one VM, direct or automatic assignment. Choose wrong in a scenario question and every downstream answer is wrong too.
Session host sizing — Microsoft publishes VM sizing guidance by workload type (light, medium, heavy, power). Know the shape of it: users per vCPU, and that GPU workloads need the NV-series with the right driver extension.
Multi-session Windows vs single-session client OS, and the licensing entitlements that make AVD cheap (Microsoft 365 E3/E5, Windows E3/E5, or per-user access pricing for external users).
Images: custom images via Azure Compute Gallery, replication to the regions you deploy in, and the generalise/sysprep step people forget.
App groups and workspaces: RemoteApp vs Desktop app groups, how app groups attach to workspaces, and that users need an assignment to the app group and the "Desktop Virtualization User" role.
Networking: bandwidth and latency requirements, RDP Shortpath (managed and public networks), and the fact that AVD is a reverse-connect service — session hosts make outbound connections, so you don't open inbound RDP. That reverse-connect model is a favourite question.

2. Plan and implement identity and security

The identity chapter is where most people lose marks, so slow down here.

Session hosts must be joined to something: AD DS domain-joined (with Entra Connect syncing to the cloud), Entra Domain Services, or Entra-joined. Each has different implications for FSLogix profile storage and for what authentication works. If profiles live on Azure Files with identity-based authentication, the storage account needs the right domain configuration — this combination is the single most-tested integration on the exam.

Then: Conditional Access policies targeting the AVD app, MFA, RBAC roles specific to AVD (Desktop Virtualization Contributor, User, Reader, Host Pool Contributor), Azure Firewall or NSGs plus the required service tags and URLs, and Microsoft Defender for Cloud coverage of session hosts.

3. Plan and implement user environments and apps

FSLogix is the heart of this domain. Profile containers vs Office containers, VHD/VHDX on a file share, Cloud Cache for resilience across storage, and the storage options ranked: Azure Files (premium for real workloads), Azure NetApp Files (highest performance, highest cost), or a file server on IaaS. Know the IOPS-per-user guidance and know that Standard storage will make users hate you.

Also: MSIX app attach (how the package mounts, what the staging/registration lifecycle looks like), Start menu and language pack customisation, printing and device redirection through RDP properties.

4. Monitor and maintain

Azure Monitor Insights for AVD (which workbook shows what), Log Analytics with the diagnostic settings you must enable, session host scaling with the scaling plan feature, drain mode for maintenance, and image update workflows. Plus the backup and BCDR story: what you back up for pooled (nothing much — the profiles) versus personal (the VMs).

Build this, don't just read it

AZ-140 punishes pure theory harder than most Microsoft exams because the questions are operationally specific. Spend a weekend building:

A resource group with a small VNet peered to nothing, just to keep it simple.
An AD DS setup — a domain controller VM, or Entra Domain Services if you'd rather.
A pooled host pool with two session hosts from a marketplace image.
An Azure Files premium share with identity-based auth, and FSLogix configured via GPO or registry to point at it.
Log in as two different users, confirm the profile VHDs appear on the share, then log in as one of them on the other session host and confirm the profile follows.

That last verification is the moment AVD clicks. It costs maybe $15 of Azure credit if you delete it the same weekend. Set a budget alert first.

Where people actually lose marks

The case study. You get one long scenario — company, existing estate, requirements, constraints — and several questions. Read the requirements section twice before answering anything, and take note of the compliance and cost constraints because they're what discriminate between the plausible answers. Once you advance past the case study you cannot return to it.

Identity combinations. "Entra-joined session hosts with FSLogix profiles on Azure Files" has different requirements than "AD DS-joined with the same storage." Make a table of the three join types × the storage options and fill in what works. That table is probably worth 5% of your score.

Confusing AVD with Windows 365. They're different products with different management models and the exam will offer Windows 365 as a distractor. AVD = you manage the infrastructure, flexible, pooled possible. Windows 365 = fixed per-user Cloud PC, simpler, no pooling.

The four-week plan

Week 1: Microsoft Learn AZ-140 path, front to back, plus the official study guide as a checklist.
Week 2: build the lab above. Break FSLogix on purpose and fix it.
Week 3: identity and security deep dive — the weakest area for most people — plus networking and Conditional Access.
Week 4: questions only, timed, plus one full case-study rehearsal. Working through an AZ-140 practice test is how you find out whether your lab knowledge survives contact with exam phrasing, which is a genuinely different skill.

Worth it?

For a specialty exam, AZ-140 has an unusually good ratio of effort to market value. VDI is unglamorous, which means fewer people study it, which means the ones who can actually troubleshoot an FSLogix profile-load failure at 8am are in demand. If you're already doing Azure infrastructure work, this is one of the cheapest ways to become the person your organisation can't easily replace.

Take a free AZ-140 practice test to find your weak domain first — or see the full breakdown on the AZ-140 exam page. If you want each answer explained while you drill, ai.examcert.app does that and costs about as much as a coffee.

Is AWS DevOps Engineer Professional Worth It 2026? A Straight Answer for Working Engineers

ExamCert.App — Mon, 17 Aug 2026 15:13:11 +0000

Someone asks "is AWS DevOps Engineer Professional worth it 2026" on Reddit roughly once a week, and the thread always splits into two camps: people who say certs are meaningless and people who say it doubled their salary. Both are wrong in the same way — they're answering a question about markets with an anecdote about themselves.

Here's a more useful framing. The DOP-C02 is worth it in exactly three situations, and it's a waste of $300 and 100 hours in every other one. Let me be specific about which is which.

What you're buying

$300, 180 minutes, 75 questions (65 scored, 10 unscored). Six domains:

SDLC Automation (~22%) — CI/CD pipelines, CodePipeline, CodeBuild, CodeDeploy, artifact management, deployment strategies
Configuration Management and IaC (~17%) — CloudFormation, CDK, Systems Manager, AMI lifecycle, multi-account provisioning
Resilient Cloud Solutions (~15%) — multi-AZ and multi-region, failover, backup and restore, RTO/RPO
Monitoring and Logging (~15%) — CloudWatch, X-Ray, EventBridge, log aggregation, metric filters, alarms
Incident and Event Response (~14%) — automated remediation, event-driven architecture, troubleshooting
Security and Compliance (~17%) — IAM at scale, Config rules, GuardDuty, Security Hub, secrets management

The DOP-C02 domain breakdown is worth skimming before you decide — the weightings tell you where your gaps will cost you.

There's no formal prerequisite anymore, but the exam assumes you've lived in AWS for two-ish years. This is a professional-level exam and it earns that label: questions are three-paragraph scenarios with five plausible answers, and the correct one usually hinges on a single constraint buried in the second paragraph.

Situation 1: worth it — you're at a consultancy or partner

If your employer is an AWS Partner, certifications are literally revenue. Partner tier requirements count certified headcount, and tier affects deal registration, funding and margins. Many consultancies pay a bonus on top — I've seen $500 to $2,000 for professional-level passes — and they'll cover the exam fee and study time.

In this situation the ROI calculation isn't even close. You're being paid to take it.

Situation 2: worth it — you're trying to move from ops into platform work

This is the one nobody talks about properly. If your current title is "sysadmin" or "support engineer" and you want "platform engineer" or "DevOps engineer," you have a credibility gap that's hard to close from inside your current role, because your current role doesn't let you build the thing you want to be hired to build.

The DOP-C02 is a legible signal that closes part of that gap. Not because the certificate is magic, but because preparing for it forces you to actually build multi-account pipelines, write CloudFormation that works, and set up cross-region failover — things you can then talk about in an interview with specifics.

ZipRecruiter data from early 2026 put the national median for certified DevOps engineers around $127,000, with senior roles well north of that. Treat those numbers cautiously — certified engineers skew experienced, so the cert isn't causing the whole gap. But for the ops-to-platform transition specifically, it's one of the cheaper credible signals available.

Situation 3: worth it — you need the forcing function

Some people learn well from documentation and side projects. Others need a deadline with money on it. If you've been "meaning to properly learn CloudFormation" for eighteen months, $300 and a booked exam date is a remarkably effective productivity tool.

That's a legitimate reason. Just be honest that you're buying discipline, not a credential.

When it's not worth it

You're already a senior platform engineer at a product company. Your GitHub, your architecture decisions and your incident record speak louder. Nobody interviewing you for a staff role is going to weight a multiple-choice exam over the fact that you ran the migration. Spend the 100 hours on something with compounding returns.

You don't work with AWS daily. This exam punishes theoretical knowledge brutally. The scenarios assume operational scars — you'll be asked to choose between a blue/green deployment and a canary given a specific rollback requirement, and if you've never done either in anger the distinctions are invisible.

You're new to cloud. Start with Solutions Architect Associate or the Developer Associate. Going straight for a professional-level exam without associate-level grounding is a well-documented way to donate $300 to Amazon.

You want a raise at your current employer. Certifications rarely move internal compensation. They move external offers, which then move internal compensation. If you're not willing to interview elsewhere, the lever doesn't work.

The part that actually makes it hard

Not the services. The time.

75 questions in 180 minutes is 2.4 minutes each, and these questions are long. Three paragraphs of scenario, then five answers that each run two or three lines. Reading alone eats a minute. People who fail this exam overwhelmingly report running out of time, not running out of knowledge.

The skill you need to build is triage: read the last sentence first to find out what's being asked, then scan the scenario for the constraint that eliminates options. Cost-optimised? Least operational overhead? Minimum downtime? Existing tooling must be reused? That constraint is the whole question — the rest is set dressing designed to consume your clock.

You cannot build that skill by reading. You build it by doing long timed sets until the pattern-matching is automatic. Running free AWS DOP-C02 practice questions under a real clock, in blocks of 25 with no lookups, is worth more in the final fortnight than another course module. When two answers both look correct — which on this exam is most of the time — the AI simulator at ai.examcert.app explains which constraint disqualifies the runner-up, and that's the reasoning the exam is grading.

A realistic plan

Ten weeks at 8–10 hours a week, assuming daily AWS exposure:

Weeks 1–2: SDLC automation. Build an actual pipeline. CodePipeline into CodeBuild into CodeDeploy, with a manual approval gate. Break it deliberately.
Weeks 3–4: IaC. Write CloudFormation by hand before touching CDK. Nested stacks, StackSets across accounts, drift detection.
Week 5: Monitoring and logging. Metric filters, composite alarms, EventBridge rules, centralised logging across accounts.
Week 6: Incident response. Lambda-based auto-remediation, Systems Manager runbooks.
Week 7: Security and compliance. Config rules, Organizations SCPs, Secrets Manager rotation.
Week 8: Resilience. Multi-region patterns, and know your RTO/RPO tiers cold.
Weeks 9–10: Timed full-length runs only. Two minimum. Review every miss by reason, not by topic.

The lab work in weeks 1–8 is non-negotiable. This exam can smell people who only read.

So — worth it?

Consultancy or partner: yes, obviously, take it tomorrow.
Ops engineer trying to break into platform work: yes, it's one of the better $300 signals available.
Senior platform engineer at a product company: no, build something instead.
New to AWS: not yet — go get an associate first.

Domain breakdown and question banks are at ExamCert if you want to gauge where you stand before committing the fee.

DevNet Associate 200-901 Practice Questions Free: A Developer's Route Into Cisco

ExamCert.App — Sun, 16 Aug 2026 15:11:37 +0000

If you write code for a living and someone has suggested you pick up a network certification, DevNet Associate 200-901 practice questions free are the cheapest way to find out whether this exam is actually aimed at you. Spoiler: it probably is, and it is much less painful than CCNA for a developer.

I came at this from the software side — six years of Python, zero formal networking. Here is what the exam expects, what surprised me, and how I would sequence it.

What DevNet Associate actually is

Cisco built this certification for the person automating infrastructure rather than configuring it by hand. It is 120 minutes, roughly 90–105 questions, no prerequisites, valid three years.

The blueprint splits like this:

Software development and design — 15%
Understanding and using APIs — 20%
Cisco platforms and development — 15%
Application deployment and security — 15%
Infrastructure and automation — 20%
Network fundamentals — 15%

Read that as a developer and something jumps out: 50% of this exam is stuff you already do. APIs, software design, deployment, security practices. If you have built and shipped anything with a REST backend, you are half prepared before you open a book.

The 15% network fundamentals is where you will actually spend your study time, and it is genuinely introductory — far lighter than CCNA.

Where developers walk in already competent

APIs (20%). REST constraints, HTTP verbs and status codes, authentication schemes (Basic, Bearer tokens, OAuth2, API keys), pagination, rate limiting, webhooks. If you have consumed a third-party API you know this. The Cisco-flavoured part is knowing which platform uses which auth — but the concepts are yours already.

Software development and design (15%). Git workflows, unit testing, MVC, observer pattern, data formats, code review practice. Nothing here will trouble anyone employed as a developer.

Application deployment and security (15%). Containers, CI/CD pipelines, deployment models (bare metal, VM, container, serverless), OWASP basics, secrets handling. Again — familiar.

Run through the free DevNet 200-901 practice questions early and you will see this immediately. My cold diagnostic was strong on those three sections and embarrassing on the other three, which made planning trivial.

Where developers actually struggle

Cisco platforms (15%). This is pure product knowledge and there is no way around it. You need to know what each platform is for and roughly what its API looks like:

Meraki Dashboard API — cloud-managed networking, REST, simple.
Webex API — messaging, meetings, bots.
Cisco DNA Center — intent-based networking for campus, assurance data.
ACI — datacentre policy, APIC controller.
NX-OS / IOS XE programmability — NETCONF, RESTCONF, guest shell.
UCS Manager / Intersight — compute.
Firepower / FMC — security policy.
AppDynamics — observability.

Nobody enjoys this section. It is flashcard work. Two evenings gets you most of it.

Infrastructure and automation (20%). Model-driven programmability is the big one: YANG data models, NETCONF, RESTCONF, and the difference between them. NETCONF is XML over SSH; RESTCONF is HTTP-based and maps YANG to REST-ish operations. Then configuration management — Ansible, Puppet, Chef, and specifically that Ansible is agentless and push-based over SSH, which is why it dominates in network automation.

Also: understand what a controller-based architecture buys you versus device-by-device CLI. The exam keeps circling that theme.

Network fundamentals (15%). MAC addresses, switches versus routers, IPv4 subnetting basics, default gateways, DNS, DHCP, NAT, and common troubleshooting. If you have never thought about layer 2 versus layer 3, budget a week. It is not hard, it is just genuinely new.

The lab that made it click

Reading about NETCONF taught me almost nothing. Twenty minutes on Cisco's DevNet Sandbox — free, no hardware, real devices — taught me a lot. Grab the always-on IOS XE sandbox, hit the RESTCONF interface with curl, get a JSON blob of interface config back, and the abstract suddenly becomes concrete.

Same with Meraki: they publish a public sandbox org with a real API key. Fifteen lines of Python and you are listing devices. That single exercise covers a surprising amount of two exam domains.

If you take one piece of advice from this post: do not study Cisco platforms by reading about them. Call their APIs. The sandboxes are free and that is the entire point of the certification.

A four-week plan for a developer

Week 1 — Network fundamentals. The only genuinely unfamiliar material. Subnetting, switching, routing, DNS/DHCP/NAT. Do it first while you are fresh.
Week 2 — Cisco platforms. Flashcards plus at least one API call against each sandbox you can reach. Meraki, Webex, DNA Center, IOS XE.
Week 3 — Infrastructure and automation. YANG, NETCONF, RESTCONF, Ansible. Build something small that configures an interface programmatically.
Week 4 — Skim the developer-native domains, then timed practice. You know this material; you are checking Cisco's phrasing of it, not learning it.

Practical exam notes

120 minutes is comfortable for this exam if you are decisive. Most people finish with time left.
Expect code-reading questions — small Python snippets, JSON payloads, curl commands. Read them carefully; the trick is usually a wrong header or a mismatched status code.
Know HTTP status codes properly. 200, 201, 204, 400, 401, 403, 404, 429, 500. The 401-versus-403 distinction shows up.
DevNet Associate satisfies part of the path toward DevNet Professional, and it counts for recertification credit on other Cisco tracks.

Is it worth it?

For a developer working anywhere near infrastructure, yes. It is cheap by Cisco standards, has no prerequisites, and it credentials a genuinely useful overlap — the "I can automate the network" skill set that pure developers and pure network engineers both tend to lack.

For a pure application developer with no infrastructure exposure, it is more of a curiosity. Useful knowledge, weak signal on your CV.

Either way, take the free questions cold first. Your diagnostic split will tell you in ninety minutes whether this is a three-week exam or a three-month one for you. For most developers I have talked to, it lands closer to three weeks — which is a rare thing to be able to say about a Cisco exam.

Google Workspace Administrator Certification Exam Prep for People Starting From Zero

ExamCert.App — Sat, 15 Aug 2026 15:12:55 +0000

Google Workspace Administrator certification exam prep is oddly hard to research, because the certification is new and most of what surfaces is either Google's own course catalogue or content about the much older, much broader Google Cloud certifications. This is neither. It is a focused, genuinely entry-level admin credential, and if you are new to IT administration it is one of the more approachable ones out there.

Here is what you actually need to know before starting.

The basics

Associate Google Workspace Administrator. Two hours. $125 USD registration fee, plus tax where applicable.

The "Associate" tier matters — Google positions this below its Professional certifications, and it is genuinely aimed at people with some hands-on Workspace admin experience rather than architects. Google's own guidance suggests around six months of Workspace administration experience, though I would say the honest floor is "you have logged into the Admin console and changed something on purpose."

The single most important thing to understand about this exam

There is a comment I saw on r/gsuite that captures it perfectly: the test doesn't test for general admin knowledge, it tests for specific knowledge about Google Workspace tools.

That is the whole exam in one sentence, and it cuts both ways.

Good news if you are a beginner: you do not need years of general IT background. Nobody asks you about Active Directory schema or DNS theory in the abstract.

Bad news if you are experienced: your ten years of Microsoft 365 administration will not carry you. You will know exactly what needs to happen and have no idea what Google calls the setting or which console section it lives in. Experienced admins routinely underestimate this exam for precisely that reason and then fail it on vocabulary.

The exam wants Google's specific names for Google's specific things. Organisational units. Configuration groups. Context-Aware Access. Data regions. App access control. You need the exact terms.

What is covered

Broadly, five areas:

User and resource management. Provisioning and deprovisioning users, organisational units and how policy inheritance flows through them, groups (and the difference between a group used for email, a group used for access control, and a configuration group), shared drives, calendar resources, licence assignment.

Organisational unit inheritance is heavily tested. Understand what happens when a setting is configured at the top OU and overridden at a child OU, and which settings can even be overridden. Draw the tree out. It comes up constantly.

Security. Two-step verification enforcement, security keys, app passwords, OAuth app allowlisting, Context-Aware Access, admin roles and delegation, the security dashboard and investigation tool, alert centre. Know which of these need which Workspace edition — edition gating is a real question type.

Mail. Routing rules, compliance and content filters, spam and phishing settings, SPF, DKIM and DMARC configuration, gateways, email allowlists and denylists. Gmail routing is the most technically fiddly part of the exam. Understand the order in which routing settings apply.

Data and endpoints. Drive sharing settings and their scope, Data Loss Prevention rules, Google Vault for retention and eDiscovery, Takeout controls, mobile device management (basic versus advanced), endpoint verification.

Troubleshooting and support. Reading audit logs, using the Email Log Search, the investigation tool, and knowing what to escalate to Google support with what evidence.

How to actually prepare

Get a real tenant. This is non-negotiable and it is the single highest-return thing you can do. Google offers a free trial, and there is nothing that substitutes for clicking through the Admin console yourself. Create an OU. Put a user in it. Apply a setting at the parent and watch it inherit. Break inheritance. Create a routing rule. Set up a DLP policy.

Half this exam is "where does this live in the console," and that knowledge is basically impossible to acquire from reading. It goes in through your fingers.

Learn the vocabulary deliberately. Keep a running glossary as you go. Every time you meet a Google-specific term, write it down with what it does and where it lives. This is the study artefact that matters most for this particular exam.

Then drill questions to find the gaps. Reading the documentation front to back feels productive and mostly is not — Workspace admin documentation is enormous and you cannot tell what is exam-relevant from the inside. Questions tell you.

Run a set of free Google Workspace Administrator practice questions once you have spent a week or two in a real tenant. Do it before you feel ready — the point is diagnosis, not validation. Most people find they are fine on users and groups and quietly hopeless on mail routing and Vault.

Pay special attention to edition differences. Business Starter, Standard, Plus, Enterprise. A meaningful number of questions hinge on "the customer is on Business Standard and wants X" where the correct answer is that they need to upgrade. If you only ever practise in an Enterprise trial tenant, every feature is available to you and you will never learn these boundaries.

A realistic timeline

If you are already administering Workspace daily: two to three weeks of evening study, mostly filling gaps and learning the formal names for things you already do.

If you are coming from another platform: four to six weeks. Most of that is vocabulary and console familiarity, not concepts.

If you are new to IT administration entirely: eight to twelve weeks, and spend the first four just using a trial tenant with no exam pressure at all. Build a fake company. Onboard fake employees. Set up their groups and drives and routing. That project teaches more than any course.

Is it worth doing?

For a helpdesk or junior sysadmin trying to move into a Workspace admin role, yes — the market for Workspace admins is real, most schools and a large number of small and mid-size companies run on it, and there are far fewer certified Workspace admins than certified Microsoft 365 admins. Scarcity works in your favour.

For an experienced cloud engineer, this is not the certification that will move your career. It is narrow by design.

But at $125 and a two-hour sitting, for the right person it is a very efficient credential — and unlike a lot of entry certs, the skills it forces you to build are the actual daily work of the job.

Full exam breakdown and study material: Associate Google Workspace Administrator on ExamCert.

300-420 Exam Questions and Answers: How Cisco Writes ENSLD Design Questions (and How to Read Them)

ExamCert.App — Fri, 14 Aug 2026 15:12:55 +0000

Search 300-420 exam questions and answers and you get two kinds of results: dump sites selling stolen content, and study guides listing the blueprint you already have. Neither teaches you the thing that actually determines whether you pass ENSLD — which is understanding how Cisco constructs a design question, because once you see the pattern, a large fraction of the exam becomes readable.

Quick facts: 300-420 ENSLD, "Designing Cisco Enterprise Networks," 90 minutes, $300 USD, English and Japanese. It is a CCNP Enterprise concentration exam — pass it plus ENCOR (350-401) and you have the CCNP.

The one thing that makes ENSLD different from every other CCNP exam

ENCOR asks how does this work. ENSLD asks which design would you choose, and why.

That sounds like a small distinction. It is not. It means the correct answer is frequently not the technically best solution in the abstract — it is the solution that satisfies a stated business or operational constraint. Candidates who are strong operators fail this exam by picking the answer they would deploy in their own network, ignoring the sentence that said "the customer has limited operational staff" or "the existing hardware must be retained."

Every design question has this shape:

[Scenario: topology + current state]
[Constraint: budget / staff / migration window / existing kit / compliance]
[Requirement: what must be true afterwards]
→ Which design meets the requirement?

The constraint is the answer key. Read it first. Genuinely — read the last two sentences of the scenario before the middle, because that is where the constraint and requirement live, and it reframes everything above it.

The five constraint types Cisco uses over and over

Operational simplicity. Words like "limited staff," "minimize complexity," "ease of management." When you see these, the answer trends toward the simpler protocol, the fewer moving parts, the single area, the static solution over the dynamic one. This is the constraint that most punishes experienced engineers, who instinctively pick the elegant, scalable, complicated design.

Cost / existing hardware. "Reuse current switches," "no additional licensing." Eliminates any answer requiring new platforms or feature licenses. Often the discriminator between two otherwise identical answers.

Scalability / future growth. "Expect to triple sites over three years." Now the simple answer becomes wrong and hierarchical, summarizable, multi-area design becomes right. This is the inverse of the operational-simplicity constraint and Cisco uses both to test whether you are actually reading.

Convergence / availability. "Sub-second failover," "no single point of failure." Points at BFD, tuned timers, redundant links, FHRP choices, and at the routing protocol that converges fastest for the described topology.

Migration / coexistence. "Must run alongside the existing network during a phased cutover." This constraint makes redistribution, route filtering, and tunneling answers viable that would otherwise be poor design.

The blueprint, translated into what you'll be asked

Advanced addressing and routing (about a quarter of it). IPv4 and IPv6 addressing plans, summarization, and route filtering. The recurring question: given this address plan, where do you summarize, and what breaks if you cannot? Know why a discontiguous address plan blocks summarization, and know that "redesign the addressing" is sometimes the correct answer.

OSPF, EIGRP, BGP design. Not configuration — design. OSPF: area types (stub, totally stubby, NSSA) and which one fits a described branch, ABR placement, when multi-area beats single-area. EIGRP: stub routers, query scoping, summarization boundaries — and note that query scoping is EIGRP's answer to almost every "reduce convergence impact" question. BGP: eBGP vs iBGP, route reflectors vs full mesh (the scale question), confederations, path selection influenced by local preference, AS-path prepending, and MED. Know which attribute to use for inbound versus outbound traffic engineering, because that direction confusion is one of the most reliable ways to lose points on this exam.

WAN design. MPLS L3VPN, SD-WAN, DMVPN phases, internet-as-transport, and hybrid designs. DMVPN phase differences are a favourite: Phase 2 gives spoke-to-spoke tunnels but no summarization at the hub; Phase 3 adds NHRP redirect and lets you summarize. If a question mentions both spoke-to-spoke traffic and hub summarization, it is Phase 3.

Enterprise campus and LAN. Two-tier vs three-tier, Layer 2 vs Layer 3 access, StackWise/VSS, spanning-tree design where L2 still exists, and first-hop redundancy. Layer 3 access designs come up whenever fast convergence and loop-free operation are emphasized.

Network services and automation. QoS design strategy, multicast (PIM modes, RP placement — anycast RP for redundancy), and the newer automation and assurance content: what Cisco DNA Center does at a design level, SD-Access fabric roles (control plane node, border, edge), and LISP/VXLAN's role in the fabric. Nobody expects you to configure the fabric; you need to know what the pieces are for.

How to practice so it transfers

Do not memorize questions. Beyond the ethics of it, dumps actively hurt on this exam because they teach answer patterns rather than constraint-reading, and ENSLD reuses the same technical content with different constraints — the pattern you memorized will confidently give you the wrong answer.

Practice with a written rationale. For every question, before you look at the answer, write one line: the constraint is X, so the answer must do Y. Then check. When you are wrong, you will nearly always find you either missed a constraint or invented one that was not there. That is a fixable, trainable error and it is worth more than another twenty hours of reading.

Drill the compare-and-contrast pairs. OSPF stub vs NSSA. Route reflector vs confederation. DMVPN Phase 2 vs 3. L2 vs L3 access. Local preference vs AS-path prepending. Each of these is a question generator, and being instant on them buys you time for the genuinely hard ones.

Work timed. 90 minutes is tight for scenario questions with paragraphs of setup. Practise skimming to the constraint fast.

You can get a feel for the actual question style with a set of free 300-420 practice questions — the useful part is not the score, it is noticing how often you can eliminate two answers immediately once you have identified the constraint. And when you miss one, get the reasoning rather than just the letter; ai.examcert.app explains why the winning design beat yours, which is exactly the muscle this exam tests.

The short version

ENSLD is not a hard exam technically. Almost everything on it is CCNP-level content you have already met in ENCOR. What makes it fail people is that it asks a question type they have never practised: given these constraints, which of these four working designs is correct?

Train that specific skill — find the constraint, then eliminate — and the exam gets dramatically smaller. The full 300-420 breakdown and question bank is here if you want to work topic by topic.

300-410 Exam Prep 2026: A Lab-First Plan for ENARSI (Because the Theory Path Fails Here)

ExamCert.App — Thu, 13 Aug 2026 15:14:48 +0000

Most 300-410 exam prep 2026 advice tells you to watch a video course, read the OCG, and then do practice questions. That order works fine for ENCOR. It fails a surprising number of people on ENARSI, and I think the reason is structural rather than about effort.

ENARSI is a troubleshooting exam wearing an implementation exam's clothing. The blueprint says "Implementing Cisco Enterprise Advanced Routing and Services", but a large share of the question weight lands on: here is a broken network, here is the output, what is wrong. You cannot build that skill by reading. You build it by breaking things and fixing them.

Here's the plan I'd give anyone starting today.

The exam, briefly

90 minutes, roughly 55–65 questions
$300 USD
Mixed formats including drag-and-drop and multi-choice; scored on a variable scale
Counts as a CCNP Enterprise concentration exam (with ENCOR as the core)
Blueprint weight: Layer 3 technologies ~35%, VPN technologies ~20%, Infrastructure security ~20%, Infrastructure services ~25%

That Layer 3 chunk is dominated by EIGRP, OSPF, BGP, and route redistribution — and redistribution is where the exam does its worst damage.

Step 0: Find out where you actually are (one evening)

Before you buy anything, sit a diagnostic. Not to feel good — to allocate the next eight weeks.

Run a timed set at ExamCert's 300-410 practice test, then bucket your misses into the four blueprint domains. Almost everyone finds one domain is dragging the average, and it's usually not the one they expected. Mine was infrastructure services — I'd written off DHCP, NTP, and NetFlow as trivial and lost a genuinely embarrassing number of points there.

Step 1: Build the lab before you study (weekend one)

Non-negotiable, and it's cheaper than it used to be.

Options:

Containerlab + FRR/Cisco images — lightest weight, runs on a laptop, excellent for BGP and OSPF work
EVE-NG or GNS3 with IOS-XE / IOSv images — closest to the real CLI
CML (Cisco Modeling Labs) Personal — paid, but officially supported and the least fighting with images
Cisco's own sandbox labs — free, time-limited reservations, good for spot practice

You want to be able to build a six-to-eight router topology and tear it down in under five minutes. If your lab takes an hour to set up, you'll stop using it by week three. Automate it: save your topology, script your base configs.

Step 2: The redistribution month (weeks 1–4)

If ENARSI has a boss fight, it's route redistribution and route filtering. Here's the sequence that finally made it click for me:

Week 1 — one protocol at a time. OSPF alone: multi-area, LSA types 1 through 7, virtual links, stub/NSSA/totally-stubby behaviour, and what each area type filters. Actually configure each stub type and run show ip ospf database to see which LSAs disappeared. Reading the table of stub types teaches you nothing; watching an LSA vanish teaches you permanently.

Then EIGRP alone: named mode, unequal-cost load balancing with variance, stub routing, summarisation and the summary route's effect on the topology table.

Then BGP alone: eBGP vs iBGP loop prevention, next-hop-self, route reflectors, the path selection algorithm in order (weight, local pref, locally originated, AS path, origin, MED, eBGP over iBGP, IGP metric, oldest, router ID). Memorise that order. It gets tested directly and it's free points.

Week 2 — two protocols, one direction. Redistribute OSPF into EIGRP. Watch the metric problem appear. Fix it. Reverse it. Understand seed metrics, and why EIGRP needs one and OSPF doesn't.

Week 3 — mutual redistribution, two points. This is where routing loops and suboptimal routing appear, and where the exam lives. Build the classic two-router mutual redistribution topology. Break it deliberately. Then fix it three different ways:

Route tags (tag on the way out, deny tagged routes on the way back in)
Administrative distance manipulation
Prefix lists and distribute lists

Do all three. The exam will hand you a scenario where two of the three are unavailable.

Week 4 — filtering and path control. Prefix lists, route maps, offset lists, and PBR. Write a route map with multiple sequences and understand the implicit deny at the end. That implicit deny has failed more configs than any other single thing in this blueprint.

Step 3: VPN and security (weeks 5–6)

DMVPN is the big one. Phase 1 vs Phase 2 vs Phase 3, NHRP registration, spoke-to-spoke tunnels, and how the routing protocol behaves over each phase. Build a hub and two spokes. Ping spoke to spoke and watch the NHRP resolution happen in debug. This is one of those topics that's genuinely opaque until you see the packets, and then obvious forever.

Also: MPLS basics and MP-BGP for L3VPN at a conceptual-plus level, IPsec fundamentals, and GRE.

Infrastructure security: ACLs (including the ones you have to read carefully under time pressure), uRPF, CoPP, device access control, and AAA with TACACS+/RADIUS.

Step 4: Services and the "easy" domain you'll lose points in (week 7)

DHCP (server, relay, the ip helper-address behaviour and what else it forwards), NTP with authentication, SNMP versions and their security differences, syslog levels, IP SLA with object tracking, NetFlow/Flexible NetFlow.

Everyone deprioritises this domain because it feels like CCNA revision. It's 25% of the exam. Give it a full week.

Step 5: Question volume under time pressure (week 8)

Now the practice questions earn their keep, and the key word is timed. 90 minutes for ~60 questions is roughly 90 seconds each, and several of those questions include configuration output you have to actually read. If you haven't practised at pace, you will run out of clock.

My routine in the final two weeks: one 60-question timed set every other day, and on the off days, relab every question I got wrong. Not review — relab. If I missed a question about OSPF LSA filtering, I built it and watched it.

I ran sets on ExamCert and used ai.examcert.app when I couldn't work out why my answer was wrong — having the reasoning explained immediately beat a twenty-minute documentation dive at 11pm, and it kept the study session moving instead of derailing it.

The mistakes I'd warn you about

Studying redistribution from diagrams. You will believe you understand it. You will then meet a question with three redistribution points and a route feedback loop and discover you don't.

Skipping show and debug command familiarity. Troubleshooting questions hand you output. If you don't know what show ip route, show ip ospf neighbor, show ip bgp, and show ip eigrp topology look like when healthy, you can't spot the anomaly.

Neglecting BGP path selection order. It's memorisable in ten minutes and worth real points.

Booking too early. $300 a shot. Get to consistent 80%+ on fresh timed sets first.

Timeline summary

Eight weeks at 8–10 hours a week if you have working knowledge of routing. Twelve weeks if ENCOR was a while ago. Lab from day one, questions from week five, timed full sets from week seven.

Start with the diagnostic so you're not guessing at your own weak domain: https://www.examcert.app/exams/300-410/free-practice-test/

Build it, break it, fix it. That's the whole exam.

A Salesforce Platform App Builder Study Plan 30 Days Long, Built Around the 28% Domain Everyone Underestimates

ExamCert.App — Wed, 12 Aug 2026 15:15:40 +0000

Most people build their Salesforce Platform App Builder study plan 30 days out by dividing the syllabus evenly across four weeks. Five domains, thirty days, six days each, done.

That's a bad plan, and the exam's own weighting tells you why: Business Logic and Process Automation is 28% of the exam — more than a quarter of your marks in a single domain — and it's the one that's changed most in the last two years. Split your time evenly and you're overspending on App Deployment (10%) while underspending on the section most likely to sink you.

Here's a plan weighted the way the exam is. If you want to calibrate before day one, sit some free Salesforce Platform App Builder practice questions cold and see which domain collapses.

First, the numbers

60 scored questions plus up to 5 unscored, multiple-choice and multiple-select
105 minutes
Passing score: 63% — 38 of 60
$200 registration, $100 retake
No prerequisites, though it's usually taken after the Administrator cert

Official domain weighting:

Domain	Weight
Salesforce Fundamentals	23%
Data Modeling and Management	22%
Business Logic and Process Automation	28%
User Interface	17%
App Deployment	10%

63% is a comparatively forgiving bar. But note what happens if you bomb Business Logic: lose most of 28% and you need near-perfection everywhere else to clear 63%. That domain is effectively pass/fail on its own.

What this exam is actually about (and how it differs from ADM-201)

The Administrator exam asks "how do you configure and maintain an org." App Builder asks "how do you design and build an app on the platform, declaratively."

The recurring theme is a line: declarative versus programmatic. Question after question describes a requirement and asks how to meet it. The correct answer is nearly always the declarative option — Flow, validation rule, formula field, roll-up summary — and Apex is the wrong answer unless the requirement genuinely can't be done clicks-only.

Know where that line sits. Cross-object updates that aren't parent-child, complex looping over large collections, callouts to external systems, unsupported roll-ups on lookups — those are the "now you need code" cases. Everything else has a declarative answer, and the exam wants it.

Days 1–5: Data Modeling and Management (22%)

Start here even though Fundamentals is listed first, because everything downstream depends on the data model.

Relationships. Lookup vs master-detail vs many-to-many via a junction object vs hierarchical (User only). Know the consequences: master-detail cascades deletes, the child inherits the parent's sharing, and you get roll-up summary fields. Lookups don't. This is the highest-yield fact in the domain.
Roll-up summaries — and the fact that they need master-detail. If a question wants a roll-up over a lookup, the answer is Flow (or a third-party declarative rollup tool), not a roll-up summary field.
Schema Builder, external objects and external IDs, record types and how they interact with page layouts and picklist values.
Field types you can't change later, and formula fields vs stored fields.

Build it, don't read it. Create a junction object between two customs, put a roll-up on a master-detail, then try to put one on a lookup and watch it not be there. Ten minutes, permanent knowledge.

Days 6–10: Salesforce Fundamentals (23%)

Broad, shallow, and full of free marks if you cover it.

Editions and their limits, licence types (Salesforce vs Platform — a recurring question shape: "which licence supports this?"), AppExchange, the difference between declarative and programmatic customisation, org-level setup, multi-currency basics, and general platform capabilities.

This domain rewards breadth over depth. Read widely, don't rabbit-hole.

Days 11–19: Business Logic and Process Automation (28%) — the long stretch

Nine days. This is the plan's whole point.

Flow is the centre of gravity. You need working fluency, not familiarity:

Record-triggered flows: before-save vs after-save and why before-save is the performant choice for same-record field updates
Scheduled flows, screen flows, autolaunched flows, platform event–triggered flows
Decision elements, loops, collection variables, get/create/update/delete records
Fault paths and error handling
Entry criteria and the "only when a record is updated to meet the condition" option

Then the rest of the automation toolbox and when to pick each:

Validation rules (and that they fire before save and can block automation)
Formula fields, cross-object formulas, and their limits
Approval processes — entry criteria, steps, initial submission actions, recall. The exam still tests these properly; they are not deprecated.
Assignment and escalation rules
Duplicate and matching rules
Order of execution. Know it. Validation rules, before-save flows, after-save flows, workflow, triggers, roll-ups, escalation. Questions about "why didn't my automation see the updated value" resolve to order of execution.

And know the retirement story: Workflow Rules and Process Builder are out for new automation, Flow is in. Any resource that teaches Process Builder as current is stale.

Spend days 17–19 doing nothing but automation questions. This is where I found my gaps — I drilled sets on ExamCert because the questions are scenario-shaped like the real thing rather than definition trivia, and $4.99 for lifetime access with a money-back guarantee is a rounding error next to a $100 retake.

Days 20–24: User Interface (17%)

Lightning App Builder, record pages, dynamic forms and dynamic actions, component visibility rules, Lightning apps and utility bars, list views, compact layouts, path and highlights panel, page layout vs Lightning record page (two different things — the exam checks).

Also: Lightning vs Classic differences, and mobile considerations.

Dynamic Forms and component visibility come up a lot in modern versions of this exam. If your prep predates them, refresh.

Days 25–27: App Deployment (10%)

Smallest domain, quickest win. Change sets and their limits, deployment between sandbox types (Developer, Developer Pro, Partial, Full — and what data each carries), packages (unmanaged/managed/unlocked), what can and can't be packaged, and the basics of the Metadata API and SFDX.

Two days is genuinely enough. Don't overspend here.

Days 28–30: full-length timed runs

Three days, two or three complete timed attempts, and a rebuild of your miss list in between.

Rules for these final days: timed, no notes, no pausing. 105 minutes for 60 questions. If you're not clearing 75%+ consistently, move the booking — a two-week delay costs nothing, a retake costs $100.

For every miss, don't just note the right answer. Note why the option you chose solves a different problem. On this exam the distractors are all real features, so the skill being tested is discrimination between them. The AI simulator at ai.examcert.app explains that per-option reasoning, which is what turns a wrong answer into something you won't repeat.

The one-sentence version

Nine days on Business Logic, five on Data Modeling, two on App Deployment, and stop dividing your study time evenly across domains that aren't weighted evenly.

Take a free Platform App Builder practice test today, find out whether Flow is a strength or a hole, and start the thirty days from an honest number.

Docker DCA Pass Rate Tips: The 14-Day Sprint That Fixes the Three Domains Everyone Bombs

ExamCert.App — Tue, 11 Aug 2026 15:12:57 +0000

Most Docker DCA pass rate tips you find are the same four bullets: know Swarm, read the docs, do labs, good luck. Useless. So here's a specific one, built from where people actually lose marks.

The DCA is 55 questions in 90 minutes, 65% to pass, around $195–$199 USD. That's roughly 98 seconds per question — and a chunk of them are DOMC (Discrete Option Multiple Choice), which shows you options one at a time and won't let you go back. No process of elimination. No "flag it and return." You either know it or you're guessing.

That format is the real difficulty of this exam, and it changes what "prepared" means.

The domain weights, and where the bodies are buried

Rough weighting:

Orchestration — ~25%
Image creation, management, registry — ~20%
Installation and configuration — ~15%
Networking — ~15%
Security — ~15%
Storage and volumes — ~10%

Almost everyone walks in strong on images and weak on the same three: orchestration (Swarm specifically), networking, and storage. Here's why, and how to fix each.

Domain 1: Orchestration — you know Kubernetes, and that's the problem

The DCA tests Docker Swarm. Not Kubernetes. In 2026 most engineers have far more k8s hours than Swarm hours, which means the biggest domain on the exam is the one you have the least muscle memory for.

What you need cold:

docker swarm init --advertise-addr <ip>
docker swarm join-token worker      # and manager
docker node ls
docker node update --availability drain <node>
docker node promote / demote <node>

docker service create --name web --replicas 3 -p 8080:80 nginx
docker service scale web=5
docker service update --image nginx:1.25 --update-parallelism 2 --update-delay 10s web
docker service rollback web
docker service ps web               # task state, and WHY a task failed

docker stack deploy -c docker-compose.yml mystack
docker stack services / ps / rm mystack

Concepts that get tested and that people miss:

Raft consensus and quorum. How many managers survive how many failures. Why an even number of managers is a bad idea. This gets asked directly.
Replicated vs global services. Global = one task per node, and it's the answer to "run a monitoring agent everywhere."
Placement constraints and preferences. --constraint 'node.labels.region==east', and spread preferences.
Rolling update parameters — parallelism, delay, failure action. Know the flags.
Locked swarms and autolock keys. Niche, appears anyway.

Fix: stand up a three-node Swarm (multipass, Vagrant, or three cheap cloud VMs) and break it. Drain a node and watch tasks reschedule. Kill a manager and see what quorum does. Two hours here is worth ten hours of reading.

Domain 2: Networking — the driver decision tree

Know these four and exactly when each applies:

bridge — default, single host, container-to-container on the same host
host — no network namespace isolation, container uses host's stack directly
overlay — multi-host, the Swarm answer, requires a key-value store which Swarm provides
macvlan — container gets a MAC on the physical network, appears as a physical device

Then the details that get tested: the ingress network and how the routing mesh publishes a port on every node; --publish mode=host vs mode=ingress and why you'd use host mode (bypass the mesh, avoid the extra hop); embedded DNS and service discovery by service name; docker network create -d overlay --attachable and why --attachable exists.

Fix: run two containers on a user-defined bridge and ping by name. Then do the same across an overlay on your Swarm. Seeing service discovery work makes the questions trivial.

Domain 3: Storage — device mapper still shows up

Two separate things get tested and people conflate them:

Storage drivers (how the union filesystem works): overlay2 is the modern default; devicemapper (direct-lvm vs loop-lvm) still appears in questions, and knowing "loop-lvm is not for production" is a free mark. Know where the graph driver data lives (/var/lib/docker).

Volumes (how data persists): named volumes vs bind mounts vs tmpfs. docker volume create/ls/inspect/prune. Volume drivers and plugins for shared storage across a Swarm. And the classic: what happens to a volume when the container is removed (it survives — docker rm -v is what removes it).

The other 40%, briefly

Images: multi-stage builds (and why — smaller final image, no build toolchain in production), layer caching and instruction ordering, COPY vs ADD, CMD vs ENTRYPOINT (and the exec vs shell forms), .dockerignore, tagging and pushing to a registry, docker image prune vs system prune.

Security: content trust (DOCKER_CONTENT_TRUST=1), image signing, scanning, namespaces and cgroups as the isolation primitives, capabilities (--cap-drop/--cap-add), user namespace remapping, secrets in Swarm (docker secret create, mounted at /run/secrets/<name>) and why secrets beat environment variables. Also TLS for the daemon socket.

Install/config: daemon.json settings, logging drivers, restart policies, the systemd unit, and where logs actually go.

The 14-day sprint

Days 1–2: Sit a full practice set cold. Yes, before studying. You need your real domain profile, not your assumed one. Free set: https://www.examcert.app/exams/docker-dca/free-practice-test/

Days 3–6: Swarm. Build the three-node cluster, run every command above, break things deliberately. End each day with orchestration-only questions.

Days 7–8: Networking. Drivers, overlay, ingress, DNS. Hands-on both days.

Days 9–10: Storage + security. Volumes practically; storage drivers by reading; secrets hands-on.

Days 11–12: Images and install/config. Mostly revision — this is your strong area.

Days 13–14: Timed mixed sets only, and your wrong-answer log. Simulate the clock properly: 55 questions, 90 minutes, no pausing.

Three exam-day tips that actually matter

Practise the pace, not just the content. 98 seconds per question means you cannot deliberate. Time your practice sets or you'll run out of clock at question 45 with three unanswered.
DOMC punishes hesitation. Since you see options sequentially and can't revisit, "I'll come back to it" isn't available. Train for first-instinct accuracy — which only comes from reps.
Command flags are examinable. This exam asks about specific flags more than most. If you've only ever used Docker through Compose files and an IDE, spend real time in the CLI.

The full DCA overview — domains, format, cost — is at https://www.examcert.app/exams/docker-dca/.

One last thing: when a practice question's explanation leaves you unsure why the other option failed, run it through the AI simulator at https://ai.examcert.app and ask for the reasoning. On a DOMC exam, understanding the near-miss options is most of the preparation, and that's precisely what a static answer key can't give you.

Build the cluster. Break it. That's the tip.

ITIL 4 Foundation Study Plan 30 Days: A Day-by-Day Schedule That Doesn't Assume You Have Free Evenings

ExamCert.App — Mon, 10 Aug 2026 15:10:27 +0000

Most versions of an ITIL 4 Foundation study plan 30 days assume you can give it two hours a night. Real people cannot. This plan assumes 45 minutes on weekdays and 90 minutes on one weekend day — about 20 hours total, which is genuinely enough for Foundation if the hours are spent well.

Foundation is a 60-minute, 40-question multiple-choice exam with a 65% pass mark — 26 out of 40. It is a vocabulary and framework exam, not a judgement exam. That matters enormously for how you should study it: precision of definitions beats depth of understanding.

Before day 1: the one thing to get right

ITIL 4 Foundation punishes people who paraphrase. The exam asks things like "which of these is the definition of a service?" and offers four plausible-sounding sentences, one of which is the ITIL definition and three of which are how a normal person would describe it. Your job for 30 days is to replace your intuitive vocabulary with ITIL's exact vocabulary.

So: whenever you learn a term, learn it in ITIL's words, not your own. This is the opposite of my usual study advice and it is correct here.

Week 1 — the spine (days 1–7)

The goal this week is the skeleton: the Service Value System, the four dimensions, and the seven guiding principles. Everything else hangs off these.

Day 1: Key concepts — service, product, utility, warranty, outcome, output, cost, risk, value. Write each definition out longhand. These reappear all exam.
Day 2: Value co-creation, service relationships (provider, consumer, and the three consumer roles: customer, user, sponsor). The three roles are heavily tested and easily confused.
Day 3: The four dimensions — organisations and people, information and technology, partners and suppliers, value streams and processes. Learn what each covers and one example of neglecting it.
Day 4: The Service Value System overview — inputs (opportunity/demand), governance, practices, continual improvement, outputs (value).
Day 5: The service value chain and its six activities: plan, improve, engage, design and transition, obtain/build, deliver and support. Know that it is not linear.
Day 6: The seven guiding principles, one by one.
Day 7 (long session): First cold practice block, 40 questions, timed to 60 minutes. Expect something in the 40–55% range. This is diagnostic, not a verdict.

Week 2 — the guiding principles properly (days 8–14)

The principles are worth their own week because the exam tests them situationally: "a team is doing X, which principle are they applying?" You need to distinguish between them, not just list them.

Day 8: Focus on value; Start where you are. The distinction that catches people: "start where you are" means assess the current state before discarding it, not "don't change anything".
Day 9: Progress iteratively with feedback; Collaborate and promote visibility.
Day 10: Think and work holistically; Keep it simple and practical.
Day 11: Optimise and automate — specifically, that you optimise before you automate.
Day 12: Scenario drilling. Take 20 short situations and label each with a principle. Where two principles both seem to fit, write down what would make one more right.
Day 13: Continual improvement model — the seven steps and their questions ("what is the vision?", "where are we now?", and so on).
Day 14 (long session): Practice block, principles-weighted. Then re-read only what you missed.

Week 3 — the practices (days 15–21)

There are 34 practices; Foundation examines a subset in detail and the rest at the level of "what is its purpose". Do not try to learn all 34 deeply. Learn the examinable ones properly and the rest as one-line purposes.

Day 15: Incident management and service desk. Know the difference between restoring service and finding the cause.
Day 16: Problem management — and the three phases: problem identification, problem control, error control. Known error and workaround definitions are exam favourites.
Day 17: Change enablement — the three change types (standard, normal, emergency) and who authorises each. Very commonly tested.
Day 18: Service request management and service level management. SLM's focus on the whole service experience, not just metrics, comes up.
Day 19: Continual improvement practice, monitoring and event management, information security, relationship management, supplier management.
Day 20: IT asset management, service configuration management, release management, deployment management, service desk revisited. Release versus deployment is a classic confusion — learn it as a pair.
Day 21 (long session): Full timed practice set. You want to be at or above 70% by now.

Week 4 — precision and pace (days 22–30)

Content is done. This week is about eliminating the specific errors you keep making.

Days 22–24: One timed 40-question set per day. After each, sort misses into "didn't know" versus "misread". Fix the first with targeted reading; fix the second by slowing down at the question stem.
Days 25–26: Definitions blitz. Every key term, self-tested. If you cannot produce ITIL's definition, it goes on a flashcard.
Day 27: Weak-practice day. By now you will know which two or three practices will not stick. Only those.
Day 28: Full set under strict conditions — no pausing, no lookups, phone in another room.
Day 29: Light review of your flashcard pile only. No new material.
Day 30: Exam. Do not cram in the morning.

Practical notes on the loop

For the daily blocks I used the free bank at ExamCert's ITIL 4 Foundation free practice test and checked coverage against the syllabus areas listed on the ITIL 4 Foundation exam page. Any decent bank works; what matters is that you have enough questions to avoid memorising the set. If you find yourself remembering that "the one about the coffee shop is B", you have exhausted that bank and your scores are now fiction.

Three things that reliably cost marks

Confusing outputs with outcomes. An output is a deliverable; an outcome is a result for a stakeholder enabled by that output. The exam tests this directly.

Treating the value chain as a sequence. It is not. Activities can be combined in many value streams, in any order, and questions are built to catch people who assume a left-to-right flow.

Answering from workplace experience. If your organisation calls something a "change request" that ITIL would call a service request, your instinct will be wrong. When your job and the syllabus disagree, the syllabus wins for 60 minutes.

The realistic bottom line

Foundation is passable in 30 days at 45 minutes a day, comfortably, provided you spend at least a third of that time answering questions rather than reading. The people who fail it almost never fail on comprehension — they fail on precision, because they studied by reading until it felt familiar. Familiar is not the same as known. Test yourself early enough to find out which one you have.

Tableau Certified Data Analyst Exam Questions and Answers: 9 Question Types That Decide Your Score

ExamCert.App — Sun, 09 Aug 2026 15:12:14 +0000

Searching for Tableau Certified Data Analyst exam questions and answers usually turns up two useless things: leaked dumps that are years out of date, and vague "study the docs" advice. What's genuinely useful is knowing the shapes of question you'll face, because this exam has a small number of recurring patterns and each one has a reliable way to attack it. Here are the nine that matter, with what the exam is really asking each time.

The format, briefly

Tableau Certified Data Analyst is 60 questions in 120 minutes, $250 USD, and you need 750 out of 1000 scaled — roughly 75%. It's split between knowledge-based multiple choice and hands-on lab questions where you drive an actual Tableau environment. That lab component is the thing that makes this exam different from most analytics certs, and the thing most candidates under-prepare for. It's valid for two years.

Domains: Connecting to & Transforming Data (~26%), Exploring & Analyzing Data (~35%), Creating Content (~18%), Publishing & Managing Content (~11%), Understanding Tableau Concepts (~10%).

The nine question types

1. "Which join/relationship produces this row count?"

You get two tables and a result and must pick the join type — or, more often in modern Tableau, decide between a relationship (the noodle) and a physical join. The trap is that people default to joins because that's what they learned in SQL.

Attack: relationships keep tables at their native granularity and only join at query time based on the viz. Joins duplicate rows immediately. If a question mentions row duplication or inflated measures, the answer is usually "use a relationship instead."

2. LOD expression selection

FIXED, INCLUDE, EXCLUDE. Guaranteed to appear, usually more than once.

Attack: memorise this and you'll get all of them:

FIXED ignores the viz dimensions entirely — use it when the calculation must stay constant regardless of what's on the shelves.
INCLUDE adds a dimension finer than the viz.
EXCLUDE removes a dimension the viz has.

Then know the order of operations: FIXED LODs compute before dimension filters, which is why a FIXED result "ignores" your filter. If a question describes a number that stubbornly refuses to respond to a filter, you're looking at a FIXED LOD, and the fix is to add the filter to context.

3. Context filter questions

Related to the above and reliably examined. A context filter runs before FIXED LODs and before top-N filters.

Attack: whenever a question involves a Top N filter combined with another filter and the result "looks wrong," the answer is "add the other filter to context."

4. Table calculation scope and direction

WINDOW_SUM, RUNNING_SUM, INDEX(), RANK(), and the compute-using / addressing-partitioning distinction.

Attack: the exam's favourite is a running total that resets at the wrong point. Remember that "Compute Using → Table (Across)" vs "Pane (Down)" changes the partition. Anything that resets per group is partitioned by that group.

5. Hands-on: build a specific viz

The lab drops you in Tableau and says "create a dual-axis chart showing X vs Y with synchronised axes" or "add a reference line at the average."

Attack: there is no substitute for having done it. Practise these specific builds until they're muscle memory: dual axis + synchronise, combined axis, reference line/band, sets, groups, hierarchies, parameters wired to a calculated field, and a dashboard action (filter, highlight, URL). If you can build all of those without thinking, the lab is easy marks. If you can't, you'll burn 10 minutes on one question.

6. Data prep and cleaning

Pivot, split, data interpreter, union vs join, changing data types and geographic roles.

Attack: know when to use union (same columns, more rows — e.g. monthly files) vs join (different columns, same entities). Know that Data Interpreter handles Excel files with headers and footers. Know pivot turns wide to tall.

7. Calculated field debugging

They show you a formula and ask why it errors or returns nulls.

Attack: the usual culprits are aggregate/non-aggregate mixing (SUM([Sales]) - [Profit] is invalid — you can't mix), division by zero needing ZN() or a IIF([x]=0, NULL, ...) guard, and type mismatches. The aggregate-mixing one appears constantly.

8. Publishing, permissions, and extracts

Tableau Server/Cloud content: projects, permissions, extract refresh schedules, live vs extract, data source certification, and who can see what.

Attack: this domain is only ~11% and it's the one people skip because it's dull. Learn the permission model (project → workbook → view inheritance, and that Deny beats Allow) and the difference between a published data source and an embedded one. It's a few hours for a few guaranteed marks.

9. "Which chart for this question?"

Given a business question, pick the viz type.

Attack: Tableau has opinions. Trend over time → line. Part-to-whole → treemap or stacked bar, rarely pie. Distribution → histogram or box plot. Correlation → scatter. Comparison across categories → bar. Geographic → filled or symbol map. When a question stresses "compare precise values," bar beats pie every time.

How to prepare for the lab half

This is where I see people lose. The knowledge questions you can study for by reading. The lab questions you can only prepare for by building.

Get Tableau Desktop (the 14-day trial, or Tableau Public for the free-but-limited version) and rebuild the same handful of vizzes until it's automatic. Use Superstore — the exam environment uses similar sample data and the familiarity genuinely helps.

Time yourself. 60 questions in 120 minutes is two minutes each, but a lab question takes four or five. That means your multiple-choice answers need to average well under two minutes to leave room. Practise pace, not just accuracy.

Where to get realistic questions

Since the real exam's questions aren't public, what you want is a bank that mirrors the patterns above rather than a dump claiming to be the real thing. Dumps are both a ToS violation that can void your cert and usually wrong — Tableau updates this exam regularly.

I use ExamCert's free Tableau practice tests to baseline, and the full Tableau Certified Data Analyst question bank for volume — it's a couple of dollars and the explanations are the actual value, since on LOD and table-calc questions the reasoning is the thing you need to absorb. For the ones where I genuinely can't see why my answer was wrong, the AI simulator at ai.examcert.app will walk through each option, which beats scrolling forum threads.

The one-line summary

Two-thirds of this exam is LODs, table calculations, filter order of operations, and being fast in the actual product. Get those four right and the rest is reading comprehension.