Glossary & Quick Reference for VCDX Certification
Comprehensive reference for VMware certifications, technical acronyms, CLI commands, design decision templates, and study resources. Essential companion for all VCP, VCAP, and VCDX exam preparation.
Version Evolution
Glossary expanded with 3 new theory topics (VCDX Defense Prep, VCF Component Interaction Map, Anti-Patterns), key_takeaways added to all 5 core topics, learning_outcomes made specific, and references curated for certification rigor.
Learning Outcomes
- Understand VCDX prerequisites: VCP-VCF → three domain VCAP-VCF exams (VCAP-VKS mandatory) → the matching role-based VCAP-VCF → design submission and panel evaluation (Architect track; Administrator and Support challenge labs not yet available)
- Apply the Design Decision Template to structure every major decision in your VCDX document with requirement, constraint, alternatives, and risk analysis
- Demonstrate operational competence by knowing esxcli, dcli, nsxcli, and kubectl commands appropriate to each VCF component context
- Identify common design anti-patterns (over-engineering, under-specifying, ignoring day-2 ops) and articulate mitigation strategies in your defense
- Prepare for VCDX defense by whiteboarding design rationale, addressing panelist challenges, and managing time across executive summary and technical deep-dive (legacy 2024 format: 75-minute oral defence plus 45-minute design problem; the new VCDX-VCF Architect panel format is unpublished as of 24 Sep 2026)
Certification Path Quick Reference#
All VMware Certifications (Broadcom certification hub, read 24 Sep 2026)
| Certification | Exam Code | Questions | Time (min) | Pass Score | Level | Focus Area |
|---|---|---|---|---|---|---|
| VCP-VCF Architect | 2V0-13.25 | 60 | 135 | 300 (scaled) | Professional | VCF architecture and design |
| VCP-VCF Support | 2V0-15.25 | 60 | 135 | 300 (scaled) | Professional | VCF support and troubleshooting |
| VCP-VVF Administrator | 2V0-16.25 | 60 | 135 | 300 (scaled) | Professional | vSphere Foundation administration |
| VCP-VCF Administrator | 2V0-17.25 | 60 | 135 | 300 (scaled) | Professional | VCF administration |
| VCP-VVF Support | 2V0-18.25 | 60 | 135 | 300 (scaled) | Professional | vSphere Foundation support |
| NSX 4.x Professional (legacy) | 2V0-41.24 | 55 (guide) / 70 (cert page) | 135 | 300 (scaled) | Professional | NSX 4.x networking |
| Cloud Operations 8.x Professional (legacy) | 2V0-32.24 | 60 | 130 | 300 (scaled) | Professional | Aria / Cloud Operations 8.x |
| vDefend Security for VCF 5.x Administrator | 6V0-21.25 | 75 | 90 | 70 % | Professional (VCP-PCS Admin) | vDefend firewall and security |
| Avi Load Balancer 30.x Administrator | 6V0-22.25 | 65 | 90 | 70 % | Professional (VCP-AVI Admin) | Avi load balancing |
| VCAP-VCF Automation | 3V0-21.25 | 60 | 135 | 300 (scaled) | Advanced Professional | VCF Automation (domain elective) |
| VCAP-VCF Operations | 3V0-22.25 | 60 | 135 | 300 (scaled) | Advanced Professional | VCF Operations (domain elective) |
| VCAP-VCF Storage | 3V0-23.25 | 60 | 135 | 300 (scaled) | Advanced Professional | vSAN and storage (domain elective) |
| VCAP-VKS | 3V0-24.25 | 60 | 135 | 300 (scaled) | Advanced Professional | Kubernetes (VKS) — mandatory for VCDX |
| VCAP-VCF Networking | 3V0-25.25 | 60 | 135 | 300 (scaled) | Advanced Professional | NSX networking (domain elective) |
| VCAP-VCF Administrator (role-based) | 3V0-11.26 | 60 | 135 | 300 (scaled) | Advanced Professional | Administrator role — pairs with VCP-VCF Administrator |
| VCAP-VCF Architect (role-based) | 3V0-12.26 | 60 | 135 | 300 (scaled) | Advanced Professional | Architect role — pairs with VCP-VCF Architect |
| VCAP-VCF Support (role-based) | 3V0-13.26 | 60 | 135 | 300 (scaled) | Advanced Professional | Support role — pairs with VCP-VCF Support |
| VCDX-VCF Architect | Design submission + panel evaluation | n/a | Not published | Panel evaluation | Expert | Enterprise private-cloud design |
Every 2V0 and 3V0 exam listed costs USD 250 (Broadcom hub, 24 Sep 2026); exam guides are on docs.broadcom.com and registration and transcripts run through Certmetrics (cp.certmetrics.com/vmware). Legacy pre-VCF certification codes (the DCV, CMA and NV tracks, including the 3V0-xx.24 exams the 2025 Academy table listed) still appear on the older Broadcom VCDX directory page but are not part of the current VCF catalogue.
Prerequisite Chain for VCDX (all tracks, per the VCDX Certification Program Overview, retrieved 24 Sep 2026)
- Step 1 - VCP-VCF
- Hold the VCP-VCF for your track — Architect (2V0-13.25), Administrator (2V0-17.25) or Support (2V0-15.25).
- Step 2 - Three domain VCAP-VCF exams
- VCAP-VKS (3V0-24.25) is mandatory; choose two electives from VCAP-VCF Automation (3V0-21.25), Operations (3V0-22.25), Storage (3V0-23.25) and Networking (3V0-25.25).
- Step 3 - Role-based VCAP-VCF
- Pass the role VCAP that matches your VCP — Administrator (3V0-11.26), Architect (3V0-12.26) or Support (3V0-13.26).
- Step 4 - VCDX evaluation
- Architect track — design submission and panel evaluation; applications have been open since 31 Aug 2026 with no windows, dates or fees published. Administrator and Support tracks — challenge lab and evaluation, not yet available as of 24 Sep 2026.
- Existing VCDX holders
- Pass the same three domain VCAPs (VCAP-VKS mandatory) plus the role VCAP; the Overview states that no panel evaluation or challenge lab is required at this time.
- Defence format
- Legacy 2024 guide (VCDX-DCV): 120 minutes — a 75-minute oral defence (about fifteen minutes of presentation, then panel Q&A) followed, after a break, by a 45-minute design problem. Panel size, voting rules and the format of the new VCDX-VCF Architect panel are not published as of 24 Sep 2026.
Exam validity windows, document-review periods, revision rates and time-to-VCDX statistics are not published by Broadcom; plan on the sequence above rather than on any quoted duration.
Key Takeaways
- VCDX prerequisite chain (Program Overview, 24 Sep 2026): VCP-VCF → three domain VCAP-VCF exams (VCAP-VKS 3V0-24.25 mandatory + two electives) → the role VCAP matching your VCP (3V0-11/12/13.26) → VCDX evaluation. Only the Architect track (design submission + panel) is open; Administrator and Support challenge labs are not yet available.
- All listed 2V0 and 3V0 exams are 60 items, 135 minutes, 300 scaled pass mark and USD 250; space them to suit your study load. Broadcom publishes no link between VCAP scores and the depth of panel scrutiny, so treat any such claim as unsourced.
- Panel composition, voting rules and pass thresholds for the VCDX-VCF Architect panel are not published as of 24 Sep 2026. The legacy 2024 guide describes a 120-minute defence (75-minute oral defence + 45-minute design problem) without stating panel size.
- Document-review periods, revision rates and scheduling lead times are not published as of 24 Sep 2026; the older '2–4 weeks / ~40 % revise' figures were unsourced and are withdrawn. VCDX-VCF Architect applications have been open since 31 Aug 2026; fees are not published.
Technical Acronyms & Glossary (50+ Terms)#
A
- ABX
- Action Based eXtensibility. Extensibility actions (small Python, Node.js or PowerShell functions) run from VCF Automation / Aria Automation to extend provisioning workflows without a full orchestrator workflow.
- AFI/SAFI
- Address Family Identifier / Subsequent AFI. BGP routing family (IPv4 unicast = AFI 1, SAFI 1; IPv6 unicast = AFI 2, SAFI 1).
- ALB
- Advanced Load Balancer — the VMware Avi Load Balancer (NSX Advanced Load Balancer); Controller cluster plus Service Engines providing virtual services, WAF and GSLB. Licensed as an add-on to VCF.
- ARP
- Address Resolution Protocol. Layer-2 protocol for IP-to-MAC mapping. On NSX overlay segments the host transport nodes suppress ARP broadcast using the central control plane's ARP table (ARP suppression); the Tier-0/Tier-1 service routers can proxy-ARP for NAT and load-balancer VIPs on their uplink subnets. The Global Manager is a management-plane component and does not answer ARP.
- ASN
- Autonomous System Number. BGP identifier; unique per routing domain. Private-use ranges: 64512–65534 for 2-byte ASNs and 4200000000–4294967294 for 4-byte ASNs (RFC 6996); 65535 is reserved. VCF edge clusters use a reserved private ASN on the Tier-0 with eBGP to the fabric.
B
- BGP
- Border Gateway Protocol. Exterior routing protocol; used for multi-site and upstream DC connectivity (Tier-0 router as BGP speaker).
- BUM
- Broadcast, Unknown Unicast, Multicast. Network traffic requiring replication (flooded to all destinations).
- BYOK
- Bring Your Own Key. Pattern where the customer supplies and controls the key material (external KMIP key provider for vSAN and VM encryption) instead of using the vCenter Native Key Provider; required where key custody must be separate from the virtualisation platform.
C
- CLOM
- Cluster Level Object Manager. vSAN component that decides object placement and checks that the storage policy (FTT, stripe width) can be satisfied across hosts; works with DOM and LSOM.
- CNI
- Container Network Interface. Kubernetes plugin (NSX NCP, Antrea, Flannel) responsible for pod IP assignment and networking.
- CCP
- Central Control Plane. The NSX control-plane function on the NSX Manager cluster that computes runtime state (logical switching, routing, DFW) and pushes it to the local control plane (LCP) on each transport node.
- CSI
- Container Storage Interface. Kubernetes plugin (vSphere CSI driver) bridging Kubernetes PVC requests to vSAN/external storage.
- CRUD
- Create, Read, Update, Delete. Standard database operations; used in API design.
D
- DFW
- Distributed Firewall. NSX stateful packet filter (microsegmentation enforcement).
- DHCP
- Dynamic Host Configuration Protocol. Auto-assignment of IP addresses; NSX can provide DHCP server or relay services per segment.
- DOM
- Distributed Object Manager. vSAN metadata layer; tracks objects, replicas, fault domains.
- DR
- Disaster Recovery. Recovery from catastrophic failure; backup/restore, replication, or failover to alternate site.
- DRS
- Distributed Resource Scheduler. vSphere VM load balancing across cluster; respects affinity rules.
E
- ECMP
- Equal-Cost Multi-Path. Routing load balancing across multiple equal-cost paths (NSX supports 8-way ECMP).
- ESA
- Express Storage Architecture. vSAN architecture introduced in vSAN 8.0: a single-tier, all-NVMe storage pool with no disk groups or dedicated cache tier; the default in VCF 9. OSA (Original Storage Architecture) is the disk-group design with cache and capacity tiers.
- ESXi
- Product name of VMware's bare-metal hypervisor (VMkernel plus management services), not an acronym; branded ESX in the 9.x line.
- etcd
- Distributed key-value store. Kubernetes control plane state storage (API objects, cluster config).
F
- FTT
- Failures To Tolerate. vSAN redundancy parameter (FTT=1 = tolerate 1 disk/node failure; FTT=2 = tolerate 2 failures).
- FQDN
- Fully Qualified Domain Name. Complete hostname with domain (e.g., vcenter.example.com).
G
- GSLB
- Global Service Load Balancing. Avi/ALB feature for multi-site service redundancy; DNS-based failover or BGP anycast.
- GUID
- Globally Unique Identifier. UUID format for vCenter objects (clusters, VMs, etc.).
H
- HA
- High Availability. vSphere cluster feature; one primary host per cluster monitors the others and restarts the VMs of a failed host on surviving hosts in restart-priority order, highest priority first (Highest, High, Medium, Low, Lowest), subject to admission control. VCF requires HA (and DRS) on every cluster in a VCF domain.
- HCI
- Hyper-Converged Infrastructure. Compute + storage + networking on same nodes (vSAN architecture).
- HCX
- Hybrid Cloud eXtension. Workload migration tool; enables cross-version vMotion, bulk VM replication.
- HTTP/2
- Hypertext Transfer Protocol v2. Multiplexing, server push; used by Avi/ALB for faster client connections.
I
- IDFW
- Identity Firewall. NSX feature using Active Directory context (user/group) for microsegmentation rules.
- IDS/IPS
- Intrusion Detection/Prevention System. NSX network threat prevention (passive IDS or active IPS).
- IP CIDR
- IP address range notation (e.g., 10.100.0.0/16 = 10.100.0.0 to 10.100.255.255).
L
- LAG
- Link Aggregation. Bundling multiple NIC links for higher throughput (LACP protocol for dynamic negotiation).
- LCM
- Lifecycle Management. VCF component orchestrating cluster patching, upgrades (vSAN, NSX, vSphere concurrent coordination).
- LDAP
- Lightweight Directory Access Protocol. vCenter uses LDAP for external identity provider integration (Active Directory, OpenLDAP).
- LSOM
- Local Storage Object Manager. vSAN component on ESXi managing local disk pool, object replicas.
- LSA
- Link-State Advertisement. OSPF routing packet flooding Link-State Database across area (Type 1-5).
- LSP
- Link State PDU — the IS-IS link-state advertisement unit (RFC 1195). The OSPF counterpart is the LSA carried inside a Link State Update packet; neither is an equivalent of a BGP UPDATE. In NSX designs the term appears only when the physical fabric runs IS-IS (for example an EVPN underlay).
M
- MTU
- Maximum Transmission Unit. Frame size (1500 bytes standard). NSX Geneve overlay requires a minimum of 1600 bytes on the physical underlay; 1700 or more is recommended and 9000 (jumbo frames) is typical.
- mTLS
- Mutual TLS. Service mesh encryption; client and server both present certificates (e.g., Istio mTLS).
N
- NDR
- Network Detection and Response. NSX threat detection (behavioral analysis, ML-based anomaly detection).
- NCP
- NSX Container Plugin. CNI for Kubernetes and OpenShift that maps namespaces, pods and services to NSX segments, Tier-1 gateways and load balancers; persistent volume claims are handled by CSI, not NCP.
Key Takeaways
- Use correct terminology in your VCDX defense: panelists expect you to distinguish FTT (vSAN fault tolerance) from HA (vSphere cluster restart), DFW (NSX micro-segmentation) from IDFW (identity-based firewall rules), and understand ASN/AFI/SAFI context for BGP design decisions.
- Acronyms panelists expect you to know cold: VCAP mastery requires fluent understanding of HCI/DOM/LSOM (vSAN internals), DRS/HA (vSphere availability), DFW/NSX (networking), and CSI/CNI (Kubernetes integration). Fumbling on definitions signals shallow design knowledge.
- Acronym misuse reveals design gaps: saying 'I'll use HA for DR' (conflating restart with disaster recovery) or 'DFW for north-south security' (confusing distributed firewall role) undermines panelist confidence. Demonstrate clarity by using precise terminology in every design section.
Key CLI Commands Reference#
Placeholders are shown in angle brackets; replace them before running. Commands are grouped by the shell they run in, and each group cites where the command appears in the documentation. Kubernetes commands not cited are standard upstream kubectl.
ESX (esxcli)
# vSAN cluster, network and disks (VCF 9.0.1 docs p.1821)
esxcli vsan cluster get
esxcli vsan network list
esxcli vsan storage list
# Host networking (VCF 9.0.1 docs p.1641, p.2778)
esxcli network ip interface ipv4 get -i <vmk>
esxcli network nic get -n <vmnic>
# Restart the host management agents (VCF 9.0.1 docs p.1271)
/etc/init.d/hostd restart
/etc/init.d/vpxa restartPowerCLI (vSphere automation; cmdlet usage as in VCF 9.0.1 docs p.3050, p.3058)
Connect-VIServer -Server <vcenter-fqdn> -User <sso-user>
Get-Cluster | Get-VM | Where-Object { $_.PowerState -eq "PoweredOn" }
Get-Cluster <cluster> | Select Name, HAEnabled, DrsEnabled, DrsAutomationLevelvCenter appliance shell
# Service control (VCF 9.0.1 docs p.248, p.1812)
service-control --stop <service-name>
service-control --start <service-name>
service-control --restart vmware-vsan-healthNSX (NSX CLI on an NSX Manager, Edge or host transport node)
# NSX Manager cluster status (VCF 9.0.1 docs p.2026)
get cluster status
# Active manager seen from a transport node (VCF 9.0.1 docs p.2033)
get managers
# Tier-0 BGP on an Edge node, inside the Tier-0 SR VRF (VCF 9.0.1 docs p.2784)
get logical-routers
vrf <vrf-id>
get bgp neighbor summary
get bgp neighbor <neighbor-ip> advertised-routes
get route bgp
# Transport node and overlay health (VCF 9.0.1 docs p.2042, p.2063)
get host-switch
get bfd-sessions # on an Edge node
nsxdp-cli bfd sessions list # on an ESX hostSDDC Manager API (curl from any shell; token request as in VCF 9.0.1 docs p.3012, inventory endpoints in the VCF API reference)
# Token
curl -k -s -X POST https://<sddc-manager-fqdn>/v1/tokens -H 'Content-Type: application/json' \
-d '{"username":"administrator@vsphere.local","password":"<password>"}'
# Inventory
curl -k -s https://<sddc-manager-fqdn>/v1/domains -H 'Authorization: Bearer <token>'
curl -k -s https://<sddc-manager-fqdn>/v1/hosts -H 'Authorization: Bearer <token>'Kubernetes (kubectl against the Supervisor or a VKS cluster)
# Login to the Supervisor (VCF 9.0.1 docs p.5667, p.5733)
kubectl vsphere login --server=<supervisor-ip> --vsphere-username=<sso-user>
kubectl config use-context <namespace-or-cluster>
# Cluster info (VCF 9.0.1 docs p.4861 for get nodes)
kubectl cluster-info
kubectl get nodes -o wide
# Pod operations
kubectl get pods -n kube-system
kubectl describe pod <pod> -n <namespace>
kubectl logs <pod> -n <namespace> --tail=50
# Storage
kubectl get pvc -n <namespace>
kubectl describe pvc <pvc> -n <namespace>
# Network policies (VCF 9.0.1 docs p.2622)
kubectl get networkpolicies -n <namespace>
kubectl describe networkpolicy <policy> -n <namespace>
# VKS clusters in a namespace (VCF 9.0.1 docs p.6816)
kubectl get cluster -n <namespace>vSAN object and resync inspection (ESX; VCF 9.0.1 docs p.1822, p.1824)
esxcli vsan debug object health summary get
esxcli vsan debug object list
esxcli vsan debug resync listAvi Load Balancer (Controller CLI shell; Avi Load Balancer 31.2 Configuration Guide, "Using Avi Load Balancer CLI")
show virtualservice <vs-name>
show serviceengine <se-ip> interface summary
# Routes on a Service Engine, including BGP-learned (dynamic) routes
show serviceengine <se-ip> routeKey Takeaways
- Demonstrate operational competence by knowing the right CLI context for each layer: esxcli for ESX host troubleshooting (vSAN cluster health, networking), service-control for vCenter appliance services, the NSX CLI for NSX Manager cluster, Tier-0 BGP and overlay health, kubectl for Kubernetes pod and PVC inspection.
- In your VCDX defense, reference CLI examples to show you've operationalized your design: 'I confirmed every vSAN object was counted as healthy, with none in reduced-availability or policy-incompliance states, with
esxcli vsan debug object health summary get, and that the objects carry hostFailuresToTolerate: 1 withesxcli vsan debug object list(VCF 9.0.1 docs pp.1822-1823), checked Tier-0 BGP peering withget bgp neighbor summary, verified pod networking withkubectl get networkpolicies.' Panelists respect hands-on depth. - Know the difference between tools: esxcli runs on ESX, service-control runs in the vCenter appliance shell, the NSX CLI runs on NSX Manager, Edge and host transport nodes, kubectl assumes a configured kubeconfig. In your design, specify which tool operators use for each operational task (day-2 monitoring, troubleshooting, patching) to show operational thinking.
Design Decision Template (Reusable)#
Copy this template for every major design decision in your VCDX document:
---
Design Decision: [Title]
Decision ID: DD-XXX
Date: YYYY-MM-DD
Requirement
-----------
Business/technical requirement driving this decision.
Reference: REQ-YYY (Priority: P0/P1/P2)
Constraint
----------
Budget, timeline, regulatory, skill, or technology constraints limiting options.
Assumption
----------
What are we taking for granted about the environment, customer commitment, or vendor support?
Risk
----
What could go wrong? Include: Likelihood (High/Medium/Low), Impact (High/Medium/Low), Mitigation, Residual Risk.
Alternatives Considered
------------------------
1. Option A: Description, pros, cons.
2. Option B: Description, pros, cons.
3. Chosen option: Justification.
Decision Impact
---------------
Cost impact: $ amount or percentage change.
Complexity impact: learning curve, operational overhead.
Performance impact: latency, throughput, resource utilization.
Scalability impact: future growth, multi-site expansion.
Approval
--------
Approver: Name, Title
Date: YYYY-MM-DD
Signature: [if formal]
Review & Update
---------------
Last reviewed: YYYY-MM-DD
Revision history: [track changes over time]
---Key Takeaways
- In your VCDX design document, include a Design Decision Register (table of all DD-XXX decisions) as front-matter. Each decision should be 0.5-1 page in main document + full details in appendix. Panelists want to see systematic decision-making, not ad-hoc choices.
- Go deep on alternative analysis: don't just state 'we chose vSAN over external SAN.' Show quantitative comparison (cost, latency, IOPS, complexity), articulate which constraints ruled out each alternative (e.g., 'external SAN requires 10GbE infra we don't have'), and link back to requirements (e.g., 'HA requirement + budget <$X favored HCI').
- Quantify risk explicitly: assign Likelihood and Impact (H/M/L), state residual risk after mitigation, and map risks to design decisions. Panelists probe unquantified risk ('What if N+1+buffer fails?'); show you've thought through failure scenarios and have a mitigation story.
Study Resources & References#
Official VMware Documentation
📄 VCF 9.0 Official Documentation (authoritative source): https://techdocs.broadcom.com/us/en/vmware-cis/vcf/vcf-9-0-and-later/9-0.html
📄 VCF 9.1 Documentation: https://techdocs.broadcom.com/us/en/vmware-cis/vcf/vcf-9-0-and-later/9-1.html
📄 vSphere in VCF 9.0: https://techdocs.broadcom.com/us/en/vmware-cis/vcf/vcf-9-0-and-later/9-0/vsphere-in-vcf.html
📄 vSAN in VCF 9.0: https://techdocs.broadcom.com/us/en/vmware-cis/vcf/vcf-9-0-and-later/9-0/vsan-deployment-administration-and-monitoring.html
📄 NSX in VCF 9.0: https://techdocs.broadcom.com/us/en/vmware-cis/vcf/vcf-9-0-and-later/9-0/advanced-network-management.html
📄 vSphere Kubernetes Service (VKS) in VCF 9.0: https://techdocs.broadcom.com/us/en/vmware-cis/vcf/vcf-9-0-and-later/9-0/vks-on-vsphere.html
Exam Preparation Resources
- Broadcom Education — VMware Certification hub
- Official certification catalogue and exam pages; registration and transcripts run through Certmetrics (cp.certmetrics.com/vmware). https://www.broadcom.com/support/education/vmware/certification
- Official Exam Guides
- Broadcom publishes an exam guide per exam (PDF on docs.broadcom.com, e.g. the VCAP-VCF Administrator, Architect and Support guides last updated 18 Aug 2026); each lists the exam objectives, item count, duration and pass mark.
- Hands-On Labs (HOL)
- Free 24-hour lab environments; practice scenarios on real VCF/NSX/vSAN. https://www.vmware.com/resources/hands-on-labs
- Exam Objectives
- Each VCP and VCAP exam guide publishes its own objective list (the 2V0, 3V0 and 6V0 guides indexed by this Academy carry between 30 and 62 objectives each); the VCDX-VCF Architect programme publishes a blueprint and defence process rather than a numbered objective list. Map study material to the published objectives of the exam you are sitting.
- Practice Exams
- Use the sample questions in the official exam guide and the Academy quiz banks and simulator (built from the published objectives). Avoid unofficial exam-dump material in any player format — using it breaches the certification candidate agreement and the questions are frequently wrong.
Community & Blogs
- Broadcom Community (formerly VMware Communities)
- https://community.broadcom.com/ (vSphere, VCF, Kubernetes forums; communities.vmware.com now redirects here)
- Holodeck
- Documentation at https://vmware.github.io/Holodeck/ (release notes, cmdlets; the 9.1 docs are the source of truth for Holodeck 9.1), binaries on the Broadcom Support Portal, issues on https://github.com/vmware/Holodeck/issues; the Broadcom VCF Community hosts blogs and discussion.
- Community blog (williamlam.com)
- Community deep-dives, automation snippets and Holodeck walk-throughs — valuable external contributor content.
- NSX & Security Blog
- NSX federation, micro-segmentation best practices.
- Kubernetes on vSphere Blog
- TKG/VKS operational guides, Velero backup procedures.
- Reddit /r/vmware
- Community Q&A avoid relying on for certification prep (variable accuracy).
Books & Whitepapers
- VCF 9.0 Design documentation
- https://techdocs.broadcom.com/us/en/vmware-cis/vcf/vcf-9-0-and-later/9-0/design.html (architectural options, design blueprints and the design library for VCF 9.0).
- VMware Validated Solutions 9.x
- Prescriptive designs and implementation guides for VCF 9 (site protection, lateral security, ransomware recovery and others).
- Third-party books
- No specific titles are recommended here. Check that any book or whitepaper targets the VCF version you are studying; many were written for vSphere 7/8, NSX-T 3.x or NSX 4.x.
Training Courses
- VMware Official Training (Broadcom)
- Instructor-led and on-demand VCF courses; check the Broadcom catalogue for current course titles. https://www.broadcom.com/support/education/vmware
- Third-party video platforms (for example A Cloud Guru)
- Self-paced video courses (cheaper than official, but less comprehensive; check the VCF version covered).
- vBrownBag Community
- Free weekly tech talks (YouTube); guest experts discuss VCF, NSX, Kubernetes.
- VMware Hands-On Labs (HOL)
- Free 24-hour interactive labs; practice real deployments and troubleshooting.
Study Schedule Recommendation (6-Month VCDX Prep Path)
Months 1-2: VCAP Mastery
Complete the four VCAP-VCF exams the VCDX chain requires, if not already passed: VCAP-VKS (3V0-24.25, mandatory), two domain electives (3V0-21.25 Automation, 3V0-22.25 Operations, 3V0-23.25 Storage or 3V0-25.25 Networking) and the role VCAP matching your VCP (3V0-11.26 Administrator, 3V0-12.26 Architect or 3V0-13.26 Support).
Schedule exams 2 weeks apart to space out study intensity.
Use official study guides + practice exams; target 75%+ score (shows depth).
Months 2-4: Design Document Draft
Month 2: Outline structure (executive summary, current state, requirements, constraints).
Month 3: Deep-dive on logical and physical design (60% of document).
Month 4: Complete implementation, validation, appendices. Peer review (colleague review, not VMware).
Months 4-5: Document Refinement & Panelist Simulation
Revise document based on peer feedback.
Simulate panelist Q&A: Role-play with colleagues posing scenarios, challenges, trade-off questions.
Record yourself presenting; review for clarity, pace, confidence.
Month 5-6: Application & Defense Prep
Month 5: Submit application (review and scheduling timelines are not published as of 24 Sep 2026; VCDX-VCF Architect applications have been open since 31 Aug 2026).
Month 6: Prepare for defense (whiteboarding practice, final Q&A prep, logistics).
Panelist Q&A simulated (5+ mock defense sessions)
Key Takeaways
- Follow a structured 6-month VCDX prep timeline: 1-2 months finishing any remaining VCAP exams (target 75%+ scores), 2-4 months drafting and refining your design document with peer review, 4-5 months simulating panelist Q&A and recording your presentation for self-critique, 5-6 months submitting the application, submitting when ready (review and scheduling timelines are not published as of 24 Sep 2026), and preparing final defense logistics.
- Mock defense sessions are critical: conduct 5+ simulated defenses with colleagues acting as panelists, asking trade-off questions, challenging alternatives, and testing your whiteboarding ability. Record and review for clarity, pace, and confidence gaps. The legacy 2024 guide describes a 75-minute oral defence followed by a 45-minute design problem; the new VCDX-VCF Architect panel format is not published as of 24 Sep 2026, so rehearse for sustained probing rather than a fixed clock.
- Leverage free resources strategically: VMware Hands-On Labs (HOL) provides 24-hour free sandbox access to real VCF/NSX/vSAN deployments; use these to validate operational assumptions in your design (CLI commands, scaling scenarios, failure modes). Whitepaper-guided study (vSAN sizing, VCF adoption, NSX federation) ensures your design aligns with VMware best practices panelists expect.
VCDX Defense Preparation Guide#
Document Structure (Academy study outline, 50-60 pages; the legacy 2024 guide cites 100–300 pages including the application form and all diagrams for typical successful submissions)
- Executive Summary (1-2 pages)
- High-level overview of business context, customer profile, key design drivers, and expected outcomes. No technical jargon; this is for executive stakeholders and panel context-setting.
- Current State Analysis (2-3 pages)
- Existing infrastructure, gaps, pain points. Include capacity, performance baseline, security posture, operational maturity. Link each gap to a design requirement (e.g., "Limited monitoring → RTM requirement for 99.99% availability SLA").
- Requirements & Constraints (3-4 pages)
- Functional (workload performance, scalability), non-functional (availability, RTO/RPO, security), operational (day-2 patching, monitoring, cost), regulatory (compliance, licensing). Prioritize (P0=blocking, P1=high, P2=nice-to-have).
- Logical Design (15-20 pages)
- Multi-diagram section showing layers (compute, storage, networking, security, management, monitoring). Address each requirement explicitly (e.g., "Req-022: HA Across Zones → vSphere cluster design with DRS + affinity rules + N+1 sizing"). Use decision IDs (DD-XXX) for major choices.
- Physical Design (10-15 pages)
- Hardware specs, network topology, cable diagrams, IP addressing, zoning. Address capacity, power, cooling. Show how logical maps to physical (e.g., "Tier-0 GW logical → 2x NSX Edge nodes across availability zones physical").
- Implementation Plan (5-8 pages)
- Phased approach (Phase 1: SDDC Manager + ESXi, Phase 2: vSAN cluster, Phase 3: NSX). Timeline, resource requirements, rollback points. Risk-driven (highest risk deployed first for validation).
- Validation & Testing (2-3 pages)
- Post-implementation tests (HA failover, DFW rule validation, vSAN rebuild, vMotion scenarios). Success criteria for each (e.g., "VM restarts <5 min, zero data loss").
- Appendices
- Design Decision details (full DD-XXX analysis), network diagrams, CLI command examples, cost breakdown, licensing summary, monitoring/alerting plan, runbook snippets.
Common Panelist Questions & Responses
Why This & Not That?
Q: Why vSAN instead of external SAN?
A: (Link to DD-XXX) HCI simplifies operationalization, reduces CAPEX by ~30% vs. SAN+fabric, and co-locates storage with compute for lower latency. Customer has no existing SAN investment, so external SAN adds OpEx complexity without benefit.
Q: Why NSX-T instead of VDS?
A: NSX provides east-west microsegmentation (identity-based DFW rules) required by Req-018 (identity-driven security). VDS cannot enforce policy based on Active Directory context; NSX's IDFW feature is mandatory for our compliance requirements.
What's Your Rollback Plan?
Q: If the new design fails, how do you roll back?
A: Phase 1 (vSphere upgrade) uses parallel environments; we migrate pilot workloads to new cluster, validate for 2 weeks, then migrate remaining. Old cluster remains operational during Phase 2-3 (NSX, vSAN).
Q: What if NSX deployment fails mid-phase?
A: NSX implementation doesn't impact compute until we migrate Tier-0 gateway. VDS remains active; we simply retain old gateways until NSX is production-ready. Rollback window: 4 hours to revert Tier-0 failover and resume old gateway traffic.
How Does This Scale?
Q: What's your growth capacity?
A: Design sized for N+1+20% buffer: 36 nodes current + 4 hot-spare equivalent = 40-node headroom. vSAN stretches to 64 nodes per VSAN cluster; we stop scaling at 32 nodes (half capacity) and deploy second cluster if growth continues.
Q: How do you scale across geographies?
A: Design includes a vSAN stretched cluster with stretched NSX segments for multi-site HA. vSAN requires under 5 ms RTT between the data sites plus a witness at a third site; our sites measure 3 ms with low jitter. If a future site exceeds the RTT limit, we deploy a separate VCF Instance there and use replication-based DR (VMware Live Site Recovery) and HCX for workload mobility instead of stretching.
What Happens When Y Fails?
Q: What if a vSAN node fails mid-rebuild?
A: FTT=1 protects against 1 simultaneous failure. If a second node fails during rebuild (unlikely; rebuild is ~2-4 hours), that VM is at risk. Mitigation: 1. Prioritize critical VMs during rebuild (vSAN observer API). 2. Monitor rebuild progress; trigger manual remediation if >50% complete. 3. Document SLA: brief customer during rebuilds that HA is temporarily degraded.
Q: What if NSX Manager cluster quorum is lost?
A: 3-node Manager cluster; quorum survives 1 failure. If 2+ Managers fail: (1) NSX data plane (routing, DFW) continues operating independently. (2) Control plane operations (new segment creation, rule changes) blocked until quorum restored. Mitigation: geographic distribution across 3 zones; nightly backup to external storage; restore RTO <2 hours.
Presentation Tips for the Defence
Official format: the legacy VCDX defence (2024 guide) ran 120 minutes — a 75-minute oral defence (about fifteen minutes of presentation, then panel Q&A) followed, after a break, by a 45-minute design problem; Broadcom has not published the format of the new VCDX-VCF Architect panel as of 24 Sep 2026. The schedule below is the Academy practice format, not the official one.
Whiteboarding (40 min, Academy practice format)
Panelist will ask you to whiteboard key decisions (e.g., "Walk us through your compute cluster design"). Come prepared with 3-5 diagrams you know by heart:
- Compute cluster (DRS, HA, vSAN node distribution, storage tiers).
- Networking (Tier-0/1 gateways, segments, DFW enforcement points).
- Multi-site replication (NSX stretched segment, vSAN replication, RTO/RPO).
- Failure scenario (node failure → HA restart → vSAN rebuild; explain at 90 seconds/diagram).
Time Management (Academy practice format, not the official one — 75 min total)
0-5 min: Introduction (3 min presentation, 2 min panelists intro).
5-40 min: Your presentation (executive summary + design overview = 15 min, then whiteboarding = 20 min). Leave pauses for panelist clarifications.
40-75 min: Deep-dive Q&A. Panelists interrupt; expect 3-4 questions. Answer concisely (2-3 min/answer), then ask "Shall I elaborate?" to gauge depth desired.
Tip: Speak at 70% normal pace. Pause after each key point. If asked "Why?", answer in 30 seconds; if asked "How?", whiteboard it.
Scoring Criteria (What Panelists Grade)
Broadcom has not published a scoring rubric, weightings or voting rules for the VCDX-VCF Architect panel as of 24 Sep 2026; the percentages below are an Academy study heuristic.
Design Quality (40% of score)
Does the design meet all stated requirements? Are constraints addressed? Is it operationally sound?
Red flag: Missing RTO/RPO, no HA story, over-engineered for use case.
Green flag: Every requirement mapped to a design decision; constraints explicitly documented; scalability shown.
Justification Depth (35% of score)
Can you articulate WHY you chose this design? Did you consider alternatives? Can you defend against panelist challenges?
Red flag: "I chose vSAN because it's popular" or vague alternatives ("I considered SAN but it seemed worse").
Green flag: "Per DD-008, we evaluated SAN vs. vSAN using TCO analysis (cost $X, OpEx $Y, complexity score Z). vSAN won because HCI reduces OpEx 30% and simplifies patching (single LCM pipeline vs. separate storage upgrade)."
Communication Clarity (25% of score)
Do you explain concepts in plain English? Are diagrams legible? Can you whiteboard under pressure?
Red flag: Jargon soup; disorganized whiteboarding; long-winded answers.
Green flag: Concise explanations (1-2 min), clean diagrams, direct answers to questions, willingness to pivot topics.
Architectural Thinking (bonus, 10% buffer)
Do you think holistically? Do you connect design decisions (e.g., "NSX federation affects vSAN replication timing, so we must synchronize LCM patches across sites")?
Red flag: Siloed thinking ("Here's my compute, here's my storage" with no connection).
Green flag: Cross-layer insights ("vSAN rebuild impacts network I/O, so I designed NSX with QoS rules to protect vSAN traffic" or "High-frequency monitoring (Prometheus scrape every 10s) + stretched cluster = network overhead, so we use edge observability instead.").
Key Takeaways
- Your VCDX document is a structured case study (the Academy outline runs 50-60 pages; the legacy 2024 guide cites 100–300 pages including the application form and all diagrams for typical successful submissions): Executive Summary (business context) → Current State (gaps) → Requirements → Logical Design (layers, decisions) → Physical Design (hardware, topology) → Implementation Plan (phases, rollback) → Validation (tests, success criteria) → Appendices (deep-dive on each DD-XXX decision). Panelists expect systematic decision-making, not scattered ideas.
- Anticipate panelist challenges by pre-emptively addressing trade-offs in your document: 'Why vSAN over external SAN? Because HCI reduces OpEx and simplifies LCM.' 'What if a node fails during rebuild? FTT=1 tolerate 1 failure; simultaneous failures are 0.001% probability given our health monitoring and runbooks.' This proactive defense saves whiteboarding time in front of the panel (legacy 2024 format: 75-minute oral defence plus 45-minute design problem; new panel format unpublished).
- Score highest by connecting design decisions across layers: show how NSX federation affects vSAN replication timing, how monitoring strategy (centralized vs. edge observability) impacts network load, how HA/DRS cluster design shapes vSAN fault domain strategy. Panelists award bonus points for architectural thinking that shows you understand system interactions, not just individual components.
VCF Component Interaction Map#
Core VCF Architecture
VCF 9.0 Component Map
- VCF Installer (Day-0 deployment)
- Replaces Cloud Builder in VCF 9.0. OVA appliance (4 vCPU, 16 GB, 914 GB) with a binaries depot and a deployment wizard that deploys a new VCF fleet or a VCF Instance into an existing fleet. Deployed on a management-domain host it is migrated to management storage after bring-up and switched to SDDC Manager mode — it becomes the instance's SDDC Manager.
- VCF Operations and the fleet management appliance (fleet-level console)
- One VCF Operations instance per fleet, hosted in the management domain of the first VCF Instance, with the VCF Operations fleet management appliance adding the Fleet Management workflows (Lifecycle, Certificates, Passwords, Identity & Access) and collectors per instance. Provides inventory, health, capacity, cost and compliance across all instances and any standalone vCenters in the fleet. It is a VMware-built platform (not Prometheus or Wavefront); it forwards alerts and metrics to external tooling through its REST API and outbound integrations.
- VCF Automation (consumption)
- Fleet-level self-service and governance for VMs and VKS clusters (projects, blueprints, policies); optional at bring-up, deployable as a Day-N operation.
- VCF Identity Broker (identity)
- Runs as an embedded service on the management domain vCenter (HA through vSphere HA) or is deployed as a three-node appliance cluster; provides VCF Single Sign-On across vCenter, NSX, VCF Operations and VCF Automation against an external identity provider. SDDC Manager and ESX keep local authentication.
- VCF SDDC Manager (instance control plane)
- One per VCF Instance. Executes the instance workflows that VCF Operations drives: domain and cluster creation, host commissioning (also exposed in the vSphere Client), lifecycle execution, certificate and password operations, backups. Provides the SDDC Manager REST API (/v1/*) used by automation. UI deprecated in 9.0 (to be removed in a future major release); appliance and API remain.
Depends on: its embedded database, vCenter and NSX Manager connectivity, the VCF Operations integration.
Version coupling: VCF 9.0 ships with vCenter 9.0, ESX 9.0, NSX 9.0.0.0 and vSAN 9.0 (release notes BOM, 17 Jun 2025); patches within the release are applied per component inside the support matrix.
- vCenter (Compute Orchestration)
- Manages vSphere cluster, ESXi host licensing, resource pools. Enforces DRS (load balancing) and HA (automatic VM restart on failure).
Managed by: SDDC Manager executes vCenter lifecycle (upgrades, patches) driven from VCF Operations Fleet Management; cluster HA/DRS settings are set by the platform at creation.
Scaling: one vCenter per VCF domain; the configuration maximums for the exact 9.0.x build (hosts and VMs per vCenter) come from the Broadcom configuration maximums tool, not from a fixed figure in this guide.
HA integration: each cluster elects one primary host; the primary monitors the other hosts and, when a host fails, restarts its VMs on surviving hosts in restart-priority order, highest priority first (Highest to Lowest) within admission-control reserves. VCF requires HA and DRS enabled on every cluster.
- NSX (Networking & Security Orchestration)
- Tier-0 router handles north-south (external) routing (BGP, static routes, NAT). Tier-1 router handles east-west (inter-workload) routing and application connectivity. DFW enforces microsegmentation (identity-based rules via IDFW). Overlay segments replace per-workload VLANs (Geneve-encapsulated; not encrypted by the overlay — use TLS, IPsec VPN or VM encryption where confidentiality on the wire is required).
Orchestation: SDDC Manager via LCM manages NSX cluster health, licensing, and patching. NSX Manager is deployed as 3-node appliance cluster (quorum required for control plane; data plane operates independently if Manager is down).
Version coupling: NSX 9.0 is the NSX release of VCF 9.0; its configuration maximums are published in the Broadcom configuration maximums tool for the exact 9.0.x build, not fixed in this guide.
Integration with vCenter: NSX Manager registers vCenter as a compute manager; segments appear as port groups on the vDS. The NSX-embedded-in-vCenter deployment option is removed in VCF 9.0 (release notes), so NSX is configured in the NSX Manager UI/API, VCF Operations and VCF Automation, not from a vCenter plugin.
- vSAN (Distributed Storage)
- Pools local devices into a shared cluster datastore: OSA uses disk groups (cache device + capacity devices); ESA (9.0 default) uses a single-tier NVMe storage pool per host. A witness host exists only for stretched and two-node clusters. CLOM decides placement, DOM owns objects and their components, LSOM manages the local devices on each ESX host.
Orchestration: vSAN is upgraded with the ESX hosts (vSphere Lifecycle Manager image per cluster, driven from Fleet Management > Lifecycle); the on-disk format is upgraded after every host is on the new release.
Fault domains: You assign hosts to fault domains (zone, rack, host level). FTT=1 means tolerate 1 fault domain failure. Objects replicated across domains (e.g., FTT=1 with 3 hosts → each object has 2 replicas in 2 different domains).
Scaling: single cluster up to 64 hosts; vSAN storage clusters (formerly vSAN Max) disaggregate storage from compute clusters. Stretched cluster (2 sites + witness) requires under 5 ms RTT between the data sites.
- VCF Operations for logs / for networks (observability components)
- Log analytics and network flow analytics deployed and lifecycled from Fleet Management > Lifecycle; they feed VCF Operations dashboards and alerts (vCenter alarms, NSX alerts such as BGP neighbour down, vSAN health such as resync in progress or capacity thresholds, ESX warnings) and forward to external SIEM/monitoring through syslog and REST integrations.
- Cloud Builder (VCF 5.x only)
- The 5.x bring-up appliance that consumed the deployment parameter workbook and was powered off after bring-up. Not part of VCF 9.0 — the VCF Installer replaces it. Kept in this map only so that 5.2 → 9.0 comparisons name the right component.
Component Interactions
LCM Update Flow (Serialised Order)
SDDC Manager applies core-component updates in the documented order SDDC Manager → NSX → vCenter → ESX, then the vSAN on-disk format (VCF 9.0 docs; KB 390634 — for patches the order is flexible, for major and minor releases it is fixed).
Each component update in SDDC Manager triggers that component's update manager:
- vCenter update: vCenter Update Manager orchestrates ESXi host patches, waits for vMotion to complete.
- NSX update: NSX Manager updates Managers (quorum preserved), then Edge nodes (rolling update).
- vSAN update: Rolling rebalance triggers as each host is patched; rebuild can be bandwidth-constrained (monitor vSAN resync).
- ESXi update: vMotion drains VMs, applies patch, reboots, brings VMs back.
Risk: If multiple patches run out of order, HA/DRS cluster state and vSAN replica placement can be inconsistent. SDDC Manager enforces serialized order to prevent cascades.
vCenter Cluster + vSAN Integration
vCenter creates a resource pool hierarchy; ESXi hosts are assigned to clusters.
Each cluster gets a vSAN datastore (automatically created when vSAN is enabled on the cluster).
DRS scheduler respects vSAN replica placement (tries not to put both replicas on same host).
HA restart order: vSphere HA restarts VMs in restart-priority order, highest priority first (Highest, High, Medium, Low, Lowest), and can wait for a readiness condition (power on, guest heartbeat, application heartbeat) before starting the next priority group; capacity for the restarts comes from admission control. If vSAN is resyncing, restarted VMs compete with resync I/O — size slack space and consider resync throttling.
NSX Tier-0/Tier-1 + vSAN Overlay
NSX Tier-1 router provides default gateway for workload VMs on a segment.
Each segment is a logical network; VM traffic is encapsulated in Geneve tunnels (UDP 6081) to other ESXi hosts.
If a VM on Host A communicates with a VM on Host B, the NSX kernel module on Host A encapsulates the frame in Geneve and sends it from Host A's TEP to Host B's TEP over the overlay (TEP) VLAN — a separate VMkernel network from vSAN. NSX MTU consideration: Geneve encapsulation adds overhead, so the physical underlay needs a minimum MTU of 1600 for the overlay; 1700 or more is recommended and 9000 (jumbo frames) is typical.
vSAN and NSX can share the same physical network (vSAN VMkernel + NSX overlay on same vNIC) if designed for QoS separation; or dedicated vNICs for vSAN and overlay (reduces contention, higher cost).
Kubernetes Integration (vSphere Supervisor / VKS)
Enabling the vSphere Supervisor on a cluster (or zone) deploys three Supervisor control plane VMs (Tiny/Small/Medium/Large, scale-up only).
The Supervisor provisions VKS clusters and vSphere Pods; it consumes vSAN through storage policies (vSphere CSI) and NSX through the Supervisor's NSX integration (per-namespace Tier-1 or VPC, segments, SNAT, load balancer).
vSAN → Kubernetes: vSphere CSI driver creates Persistent Volumes (PVs) backed by vSAN storage policies (e.g., "high-perf SSD tier" → vSAN high-priority pool).
NSX → Kubernetes: the Supervisor's NSX integration creates per-namespace segments (or VPC subnets) and load-balancer VIPs; inside VKS clusters Antrea is the CNI; with Antrea–NSX integration the cluster's Kubernetes network policies are synchronised to the NSX inventory read-only, and NSX DFW policies built on Antrea groups (e.g. deny traffic between production and dev namespaces) are enforced by the cluster's Antrea Controller.
Scaling: a Supervisor supports hundreds of VKS clusters (VKS 3.6 with 9.1: up to 500 per Supervisor); each VKS cluster consumes vSAN and NSX resources, so sizing must account for the total node memory and storage footprint.
Monitoring Integration
vCenter Alarms → VCF Operations: vCenter publishes alarms (vSAN rebuild health, cluster DRS score, licensing) to Operations dashboard.
NSX Alerts → Operations: DFW rule violations, BGP neighbor state changes, logical router traffic anomalies.
vSAN Health → Operations: Object compliance status (replicas placed correctly), disk rebuilds in progress, capacity utilization.
Avi/ALB integration: If Avi is deployed (virtual service load balancing), its metrics (virtual service response time, pool health) also feed Operations.
Version Coupling Examples (release BOMs)
VCF 9.0 (GA 17 Jun 2025, VCF build 24755599)
VCF 9.0 ships SDDC Manager 9.0 with vCenter 9.0 (build 24755230), ESX 9.0 (build 24755229), NSX 9.0.0.0 (build 24733065) and vSAN 9.0 in the ESX bundle, plus VCF Operations 9.0, VCF Automation 9.0 and the VCF Installer. Later 9.0.x releases (9.0.1, 9.0.2) carry their own BOMs; always read the release notes BOM and the Broadcom interoperability matrix before planning an upgrade.
Within a release the components are upgraded as a set in the documented order (SDDC Manager, NSX, vCenter, ESX, then the vSAN on-disk format); patches inside a release can be applied per component within the support matrix (KB 390634).
VCF 5.2 (GA 23 Jul 2024)
VCF 5.2 ships Cloud Builder 5.2 and SDDC Manager 5.2 (build 24108943) with vCenter 8.0 Update 3a (build 24091160), ESXi 8.0 Update 3 (build 24022510, vSAN included), vSAN Witness Appliance 8.0 Update 3, NSX 4.2 (build 24105817) and Aria Suite Lifecycle 8.18 (which gates the Aria Automation, Aria Operations and Aria Operations for Logs versions).
VCF 5.2.x estates upgrade in place to VCF 9.0 (SDDC Manager 5.0 and later are supported as upgrade sources); the 9.0 BOM then replaces every component above.
Key Takeaways
- SDDC Manager applies core-component updates in the documented order SDDC Manager → NSX → vCenter → ESX, then the vSAN on-disk format (fixed for major and minor releases; patches can go in any order, KB 390634). In your VCDX design, specify patch windows (e.g., 'monthly updates on 2nd Sunday, 4-hour maintenance window') and document the rollback point per component (SDDC Manager snapshot; NSX Manager rollback only before edge and host upgrades start; vCenter file-based restore).
- Version coupling is critical: VCF 9.0 ships vCenter 9.0, ESX 9.0, NSX 9.0 and vSAN 9.0 (release notes BOM, 17 Jun 2025); VCF 5.2 ships vCenter 8.0 U3a, ESXi 8.0 U3 and NSX 4.2. You can patch components independently within the release's support matrix, but a release upgrade moves the whole set in the documented order. In your design, state the target release and BOM, cite the interoperability matrix, and clarify constraints (e.g. 'We upgrade SDDC Manager, then NSX, then vCenter, then ESX; each stage validated before the next').
- Component interactions span layers: vSAN replica placement respects vCenter DRS cluster hierarchy; NSX overlay (Geneve tunnels) shares bandwidth with vSAN replication traffic; Kubernetes CSI driver consumes vSAN storage policies; Kubernetes CNI enforces NSX DFW rules. In your design, address how these interactions are managed during operations (QoS priorities, monitoring thresholds, scaling limits) and document design decisions for each interaction point (e.g., 'DD-015: Dedicated vNICs for vSAN and NSX overlay to prevent contention during high-frequency pod churn + VM provisioning peaks').
Common Design Anti-Patterns#
Anti-Pattern 1: Over-Engineering for Non-Critical Workloads
Definition: Designing 99.99% availability (4x9s, stretched cluster, active-active replication, Avi GSLB) for dev/test or non-critical workloads that have 99.0% (1x9s) SLA.
Why Panelists Hate It
Adds 30-40% cost (extra cluster, Avi licensing, dual NSX edge nodes, stretched vSAN).
Complexity (multi-site failover, stretched vSAN requires under 5 ms RTT between data sites plus a witness site, operational overhead).
No business justification; architecture doesn't match requirement.
Red Flag Statements
- "We're deploying a stretched cluster for all our workloads because that's best practice."
- "Every application tier gets dual Avi load balancers for redundancy."
- "We're building for 99.99% availability across the board."
Corrective Guidance
Tier workloads by SLA: mission-critical (4x9s) vs. standard (3x9s) vs. development (2x9s).
Design at tier level: 4x9s gets stretched cluster + active-active, 3x9s gets local cluster + backup, 2x9s gets local cluster + manual recovery.
Example DD: "DD-004: Tiered Availability Design. Req-012 (Business SLA by workload) → 20% of workloads are mission-critical (4x9s), 60% standard (3x9s), 20% dev (2x9s). Mitigation: Mission-critical gets stretched vSAN + active-active NSX, standard gets N+1 local cluster + daily backup, dev gets N local cluster + snapshot recovery. Cost savings vs. universal stretch: 40% CAPEX reduction."
Anti-Pattern 2: Under-Specifying RTO/RPO or Business Requirements
Definition: No explicit RTO (Recovery Time Objective) or RPO (Recovery Point Objective) for workloads; assumes one-size-fits-all disaster recovery.
Why Panelists Hate It
Panelists will ask "What's your RTO for this workload?" If you answer "Uh... 4 hours?", they'll probe: "Why 4 hours? Who set that? Did the business agree?" Vague answers suggest you don't understand the customer's pain.
Design decisions (stretched cluster, backup frequency, replication lag tolerance) are justified by RTO/RPO. Without them, your design is arbitrary.
Red Flag Statements
"We'll back up everything daily." (Not tying backup to RTO/RPO.)
"Disaster recovery is handled by vSAN replication." (Not specifying failover time, data loss tolerance.)
"We'll use HCX for migration to the backup site." (Not clarifying time-to-failover, cost of active-active vs. backup-only.)
Corrective Guidance
Build a requirement table:
| Workload Tier | RTO (min) | RPO (min) | Cost Justification |
|---|---|---|---|
| Mission-Critical | 15 | 0 | vSAN stretched cluster (synchronous writes to both sites, RPO 0 for a site loss; vSphere HA restarts VMs at the surviving site) + NSX stretched segments + GSLB = recovery inside 15 minutes |
| Standard | 240 | 15 | Separate cluster per site + vSphere Replication (VCF 9.0 host-based replication to a remote vSAN cluster supports an RPO as low as 1 minute; 15 chosen) orchestrated by VMware Live Site Recovery (4-hour RTO) |
| Dev | 1440 | 1440 | Backup-based recovery; data loss acceptable if restoring from the daily backup |
Map each design decision to RTO/RPO: "DD-008: vSAN stretched cluster for tier-1. Req-005 (RTO 15 min) + Req-011 (RPO 0 for a site failure) → synchronous replication inside a vSAN stretched cluster; inter-site RTT measured at 3 ms against the 5 ms limit, so the write-latency cost is bounded and accepted for this tier. Logical corruption and deletion are not covered by stretching — the tier also gets application-consistent backups. Asynchronous replication (vSphere Replication) was rejected for this tier because any non-zero RPO fails Req-011; it is the chosen method for the Standard tier."
Anti-Pattern 3: Ignoring Day-2 Operations (Beautiful Design, No Operational Plan)
Definition: Design is logically and physically sound, but no monitoring, alerting, runbook, or operational maturity documented. Panelist asks "What's your monitoring strategy for vSAN health?" and you have no answer.
Why Panelists Hate It
A design is only as good as its operations. You've built a vSAN cluster, but if you don't monitor disk health, rebuild progress, or capacity trends, the cluster will fail silently (one day you're 99% full and unaware).
Day-2 is where 80% of operational cost lives. A beautiful design that's expensive or error-prone to operate is a failed design.
Red Flag Statements
"We'll monitor it with vCenter alarms." (Vague; which alarms? What's the SLA for alert response?)
"Operations will handle the details." (Deflecting; architecture should include operational thinking.)
"We don't have a runbook yet." (Suggests you haven't thought through failure recovery.)
Corrective Guidance
Include an Operational Maturity section:
Monitoring: Specify metrics and dashboards for each layer.
- vSAN: Disk health, rebuild progress, capacity utilization (by datastore/tier), object compliance (replica placement), latency (read/write I/O).
- NSX: BGP neighbor state, DFW rule hits (count violations/min), segment utilization, east-west latency p50/p99.
- vSphere: vSphere HA cluster health (primary host election, VM restart failures, admission-control headroom), DRS score, licence usage and expiry; vCenter HA (if used): replication state between the active, passive and witness nodes.
- Kubernetes (if deployed): Pod scheduling latency, PVC provisioning time (CSI driver), network policy enforcement.
Alerting: Define thresholds and escalation.
- vSAN rebuild time >4 hours → PAGE oncall (potential cascading failure).
- DFW rule drop rate >1000 violations/min → Alert (potential security incident or misconfigured policy).
- NSX BGP neighbor down → Alert within 5 min (routing instability).
- vSphere HA agent error on a host, or no primary host elected → Alert (VMs may not restart after a host failure; investigate immediately).
Runbooks: Step-by-step procedures for common tasks.
- "vSAN Disk Failure Recovery": Detect failed device → Confirm resync has started and the cluster has the capacity to complete it → Replace the failed device (replacing it does not speed up a resync that rebuilds components on other hosts) → Verify object compliance after resync.
- "NSX BGP Neighbor Recovery": Check link status (ping, MTU, VLAN config) → Verify BGP config (ASN match, timers) → Restart BGP neighbor → Monitor convergence (5-10 min typical).
- "vSphere HA Agent Issue": Trigger if a host reports a vSphere HA agent error → Check the HA agent state on each host → Right-click the affected host and select Reconfigure HA (VCF 9.0.1 docs p.1690) → Confirm a primary host is elected and the cluster shows no HA errors.
Cost of Operations: Estimate hourly operational cost (alerts to resolve, runbook steps, mean time to resolution [MTTR]).
- Example: "DFW rule violation alerts 5x/week → 15 min each to investigate (75 min/week opex). Mitigation: Automated runbook (DFW rule violation detector + auto-remediate via NSX API) reduces MTTR to 1 min, freeing 70 min/week opex."
Anti-Pattern 4: Single Vendor Lock-In Without Justification
Definition: Design relies entirely on VMware stack (vSAN, NSX, Aria) with no escape route if licensing costs escalate or vendor strategy changes.
Why Panelists Hate It
Panelists want to see you've evaluated alternatives: What if customer budget drops 20%? What if VMware licensing becomes unaffordable? A single-vendor design with no exit strategy is risky.
You've trapped the customer into a costly renewal cycle.
Red Flag Statements
"We're using vSAN because it's VMware." (No alternative analysis.)
"NSX is the only option for security; no alternatives." (Dismissive; Kubernetes NetworkPolicy + Istio exist.)
"We can't use external storage because VCF only does vSAN." (Incorrect; VMFS on FC, NFS v3 and vVols are supported principal storage for workload domains, and supplemental datastores can be added to any cluster.)
Corrective Guidance
Evaluate alternatives transparently, even if VMware wins:
DD-009: Principal Storage Architecture. Req-003 (HCI performance, operational simplicity). Alternatives inside what VCF 9.0 supports as principal storage for a workload domain: (A) vSAN ESA (included in the VCF per-core licence up to 1 TiB per core, tight vSphere integration, storage-policy driven). (B) VMFS on Fibre Channel (existing array investment, array-side features, separate fabric and array team). (C) NFS v3 (simple, array-dependent performance, limited policy integration). (D) vVols (array-managed per-VM objects where the array supports it). Ceph and non-VMware HCI stacks are not VCF principal storage and are recorded as rejected on supportability, not on price.
Analysis (illustrative figures — replace with the customer's quotes):
| Criteria | vSAN ESA | VMFS on FC | NFS v3 | vVols |
|---|---|---|---|---|
| Incremental cost (CAPEX) | NVMe devices in the hosts; licence capacity included to 1 TiB/core, vSAN TiB add-on beyond | Array + FC fabric (or reuse) | Array (or reuse) | Array with vVols support |
| OpEx | One team, one console (vCenter / VCF Operations) | Array and fabric team, separate monitoring | Array team | Array team + VASA provider lifecycle |
| Ops complexity (1-5 scale) | 2 | 3 | 2 | 3 |
| Performance scaling | Linear with hosts | Array-bound | Array-bound | Array-bound |
| vSphere integration | 5 (native, SPBM) | 3 (datastore) | 3 (datastore) | 4 (SPBM via VASA) |
| Scaling | 64 hosts per cluster; vSAN storage clusters for disaggregation | Array limits | Array limits | Array limits |
| Exit cost | Medium (storage policies, host hardware specific) | Low (array portable) | Low | Medium |
Conclusion: vSAN ESA chosen because (1) the capacity is largely covered by the VCF licence already being paid for, so the incremental cost is the NVMe devices, which the host BOM already carries; (2) operational complexity is lowest (one team, one console, policy-driven); (3) performance scales with the cluster; (4) the operations team already runs vSphere. Trade-off: exit cost is medium and host-hardware-bound; mitigation = keep a supplemental NFS or FC datastore pattern documented for workloads that outgrow vSAN, and re-evaluate at the hardware refresh.
Justify VMware decisions with crisp reasoning, not vendor loyalty.
Anti-Pattern 5: Not Sizing for N+1+Buffer
Definition: Design spec is exactly what's needed for current workload (e.g., 36-node cluster for 100% utilization); no headroom for failure recovery or growth.
Why Panelists Hate It
If a cluster is sized to run at 100% on N hosts, one host failure leaves it needing about 103% of the remaining capacity on 36 hosts — HA cannot restart everything and vSAN has no space to rebuild.
Growth expectations (even 10-20% over 2 years) will exceed capacity within 18 months.
Operational incidents (planned maintenance, unplanned failures) have no slack.
Red Flag Statements
"We've sized the cluster to exactly match current demand." (No buffer.)
"If a node fails, we'll manually migrate workloads to the backup site." (Defeating HA automation.)
"We'll add nodes later if needed." (Reactive; design should be proactive.)
Corrective Guidance
Size for N+1+buffer:
N = hosts needed to carry the workload (CPU, memory and vSAN capacity after the storage policy) at the target utilisation.
N+1 = one host more than N, so a single host failure or one host in maintenance leaves N hosts that still carry every VM and give vSAN room to rebuild; N+2 where two concurrent failures (or maintenance plus a failure) must be tolerated.
Buffer = headroom for growth and operational slack, expressed as a utilisation ceiling (for example 70% of post-policy capacity) with a date by which it is consumed.
Example (storage-led; do the same calculation for CPU and memory and take the largest host count):
Workload: 100 TB of VM data, 200 VMs, protected with FTT=1 RAID-5 on vSAN ESA (efficiency 0.8) → 125 TB of raw capacity consumed; vSAN slack and rebuild space 25% → 167 TB raw needed.
Host contribution: 8 × 7.68 TB NVMe = 61 TB raw per host → N = 167 / 61 = 2.7 → 3 hosts on storage alone; CPU/memory for 200 VMs sets N = 6 in this example.
N+1: 7 hosts (one can fail or be in maintenance with the workload still placed and compliant); HA admission control reserves one host's worth of CPU and memory.
Buffer: 20% annual growth → 100 TB becomes 120, 144, 173 TB; at 7 hosts (427 TB raw) the 70% ceiling (299 TB raw ≈ 179 TB of data at 0.8 × 0.75) is crossed during year 4, and the 60% add-a-host trigger (≈154 TB of data) during year 3 → budget the eighth host for year 3, not year 1.
Result design decision: "DD-012: Cluster sizing N+1 with a 70% utilisation ceiling. Req-008 (single-host failure tolerance, 20% annual growth). 7-host vSAN ESA cluster: 6 hosts carry the workload, one is failure/maintenance headroom; HA admission control = one host; storage policy FTT=1 RAID-5 (4+1 available from 6 hosts). Growth trigger: add a host when sustained utilisation passes 60% on any dimension (forecast: year 3); the 70% ceiling is forecast for year 4."
Anti-Pattern 6: Mixing Design & Implementation Concerns
Definition: Design document conflates "what the system does" (design) with "how we build it" (implementation). Example: "We'll deploy the management domain with the VCF Installer OVA, which needs 914 GB of disk and about 90 minutes to bring up." (Implementation detail; design should abstract this.)
Why Panelists Hate It
Design states requirements and decisions; the runbook states the tool steps. If your design document reads like the VCF Installer wizard, a panel will ask what the requirement behind each step was and what happens when the tool version changes.
Implementation details (CLI commands, file paths, deployment tooling) belong in runbooks, not the design document.
Panelists want to see architecture thinking, not step-by-step procedures.
Red Flag Statements
"We'll use Terraform to deploy NSX segments because it's faster." (Tool-specific; what's the design principle?)
"The Installer will bring the cluster up in 90 minutes." (Implementation; the design states the requirement — automated, validated, repeatable bring-up — and the decision to use the platform's installer.)
"We'll SSH into ESXi hosts and run esxcli commands to configure vSAN." (Procedure; design should abstract to "vSAN is configured via vCenter or equivalent CLI tools.")
Corrective Guidance
Separate concerns:
Design Layer: "The first VCF Instance is deployed by the VCF Installer from a validated deployment specification (management domain: vCenter, NSX, vSAN, SDDC Manager; VCF Operations with fleet management for the fleet). Requirement: bring-up is automated, validated before execution and repeatable from the saved specification, so that human error and deployment time are minimised and the specification is the as-built record."
Implementation Layer (Appendix Runbook, VCF 9.0.1 wizard): "Initial Deployment Procedure: 1. Deploy the VCF Installer OVA (4 vCPU, 16 GB, 914 GB) on a management-domain host. 2. Download the VCF binaries to the Installer depot (online, or offline with the VCF Download Tool). 3. In the Installer UI run Deployment Wizard > VMware Cloud Foundation > A new VCF fleet and complete the pages (deployment model, VCF Operations, VCF Automation, vCenter, NSX Manager, storage, hosts, networks, vDS profile, SDDC Manager). 4. Review, download the JSON specification, run the validations and resolve every error. 5. Deploy and monitor the Tasks panel. 6. On completion the Installer appliance is migrated to management storage and runs as SDDC Manager; verify the instance under VCF Operations > Fleet Management > Lifecycle. If a task fails, fix the cause and retry the deployment."
Anti-Pattern 7: Not Addressing Security at Every Layer
Definition: Design focuses on compute/storage/networking performance but relegates security to a single NSX DFW rule set. Missing: encryption (in-transit, at-rest), identity/access control, audit logging, compliance (FIPS 140-3, PCI DSS).
Why Panelists Hate It
A performant system that's insecure is a liability. Panelists assume you've thought about security in every layer: compute (vSphere privilege separation, VM isolation), storage (vSAN encryption, backup encryption), networking (NSX DFW, encryption, RBAC), and management (vCenter SSO, audit logging).
Missing security layer design suggests shallow thinking.
Red Flag Statements
"NSX DFW will handle all security." (Implies compute/storage security is out-of-scope.)
"We don't need encryption because traffic stays in the data center." (Ignoring insider threats, regulatory requirements.)
"Identity management is just vCenter AD integration." (Missing RBAC per-workload, audit trail requirements.)
Corrective Guidance
Include a Security Design section (5-8 pages):
Compute Security:
- vSphere VM isolation (hypervisor security patches, vTPM for attestation).
- VM privilege separation (run non-privileged VMs in restrictive resource pools).
- Trusted execution (TPM attestation if required by PCI/HIPAA).
Storage Security:
- vSAN data-at-rest encryption (AES-256 XTS, VCF 9.0.1 docs p.1779; confirm the FIPS 140-3 validation status of each component if FIPS is required).
- Snapshot encryption (encrypted copies for backup/DR).
- Secure erase (data destruction if hardware decommissioned).
Networking Security:
- NSX DFW (microsegmentation; identity-based rules if using IDFW).
- Encryption in-transit (vSAN data-in-transit encryption, AES-256, VCF 9.0.1 docs p.1778; encrypted vMotion; TLS for management traffic; IPSec VPN where traffic leaves the site).
- North-south (Tier-0 security appliance, WAF on Avi if exposed to internet).
Identity & Access:
- vCenter SSO (single sign-on via AD/LDAP).
- RBAC (role-based access control; example: "cluster admin" role vs. "storage viewer" role).
- Audit logging (vCenter audit logs, NSX API audit, vCenter events forwarded to VCF Operations for logs).
- Service account management (API tokens, API key rotation, least-privilege tokens).
Compliance:
- Map design to compliance requirements (e.g., "PCI DSS v4.0 requires strong cryptography for all non-console administrative access" (PCI DSS v3.2.1, where this was Req 2.3, was retired on 31 March 2024) → NSX DFW limits SSH to a bastion host; SSH and TLS protect management traffic).
- Encryption standards (AES-256 for data at-rest, TLS 1.2+ for data in-transit).
- Audit retention (logs retained for 1 year per SOC 2 requirement; archived to external storage weekly).
- Incident response (procedures for security event containment; example: "DFW rule violation detected → automated runbook disables segment, escalates to security team, collects NSX flow logs for forensics").
Anti-Pattern 8: Ignoring Licensing & Cost in Design Decisions
Definition: Design assumes unlimited licensing; no cost justification for dual vSAN clusters, Avi load balancers, or stretched NSX federations.
Why Panelists Hate It
VCF 9.x licensing is a per-core subscription (every CPU counts as at least 16 cores) with add-ons for capacity and services; older per-socket perpetual licences with SnS are no longer the model, and a design that mixes the two or ignores licensing can blow the budget.
Panelist question: "You've proposed 2 stretched vSAN clusters + 3 NSX Managers + 2 Avi load balancers. What's the annual licensing cost?" If you have no answer, panelists lose confidence.
Red Flag Statements
"We'll deploy VMware products without considering licensing." (Naive.)
"Licensing is a finance question, not architecture." (Abdicating responsibility; architecture drives licensing cost.)
"Enterprise licenses include everything." (Wrong; different editions and feature packs have different costs.)
Corrective Guidance
Include a Licensing & Cost section (2-3 pages):
Component Licensing Model (VCF 9.x; prices are the customer's quote, shown here as P per core-year):
- VCF: per-core subscription covering vSphere, vSAN, NSX, VCF Operations and VCF Automation; every CPU is counted as at least 16 cores (vSphere 9.0 install notes). Example: 40 hosts × 2 CPUs × 32 cores = 2,560 cores → 2,560 × P per year.
- vSAN capacity: 1 TiB of vSAN capacity per licensed VCF core is included (2,560 cores → 2,560 TiB; 0.25 TiB per core is the vSphere Foundation figure); capacity beyond that is licensed with the VMware vSAN (TiB) add-on assigned to vCenter in VCF Operations. There is no per-socket vSAN licence and no separate vCenter licence — vCenter instances are licensed from VCF Operations.
- NSX: included in VCF; not licensed per gateway or segment. Optional security add-ons (vDefend firewall/ATP) are separate subscriptions.
- Avi Load Balancer: add-on subscription (licensed per the current Broadcom price list, not per virtual service in VCF 9.x).
- Support is part of the subscription; there is no separate SnS line.
Total 5-Year Cost:
- 2,560 cores × P × 5 years, plus any vSAN TiB add-on and Avi/vDefend add-ons for the years they are in use.
- Record the licensing mode (connected licensing in VCF Operations, recommended VCF-OPS-RECD-LIC-001, or offline) and the renewal date as design constraints.
Cost Justification (via DD):
"DD-018: Licensing & Cost Model. Req-021 (annual budget ceiling). Analysis: 40 hosts × 64 cores = 2,560 VCF cores per year; included vSAN capacity 2,560 TiB exceeds the 400 TiB designed, so no vSAN add-on; Avi add-on sized for 10 virtual services. Cost per VM = annual subscription / 500 VMs; compare with the customer's current per-VM run cost, not an industry average. Mitigation: if the budget drops, reduce licensed cores (fewer or smaller hosts, right-size CPU core counts above the 16-core floor), defer Avi, and keep the stretched cluster only for the tier whose RPO/RTO requires it."
Trade-Offs & Mitigation:
If the budget cannot carry the full host count, offer a phased approach:
- Year 1: the host count the tier-1 workloads need (licensed cores follow the hosts; vSAN and NSX are already included).
- Year 2-3: add hosts (and cores) as growth triggers are hit; add the vSAN TiB add-on only if the designed capacity exceeds 1 TiB per core.
- Year 4+: add Avi or vDefend when the requirement appears, not speculatively.
This phased approach respects budget constraints and shows you've thought about cost realities.
Deferring licensing decisions to "finance will figure it out" is a sign of shallow design thinking. Panelists expect architects to balance cost, performance, and feature requirements.
Key Takeaways
- Tier workloads by RTO/RPO and SLA before designing availability: mission-critical gets stretched cluster + 4x9s availability, standard tier gets N+1 local cluster + 3x9s, dev gets cost-optimized local cluster + 2x9s. Over-engineering non-critical workloads wastes 30-40% budget; panelists spot this immediately.
- Every design decision must map to a business requirement or operational constraint, articulated in a DD-XXX decision document. Panelists ask 'Why did you choose vSAN over external SAN?' and expect a crisp answer citing RTO/RPO, cost trade-offs, and compliance drivers. Weak alternatives analysis ('vSAN seemed better') signals shallow thinking.
- Day-2 operations is 80% of cost; include monitoring strategy (metrics and thresholds), alerting (SLA for response), runbooks (MTTR targets), and OPEX estimate in your design. Panelists will ask 'What happens when a vSAN disk fails?' and expect a detailed runbook response, not 'We'll call support.'
References
- VCDX Certification Program Overview (Broadcom; undated PDF, retrieved 24 Sep 2026)Tier 1 — Official
- Announcing the Next Evolution of VMware Certified Distinguished Expert (VCDX) — VCF blog, 13 Nov 2025Tier 1 — Official
- Elevate Your Enterprise Value with New VCAP and VCDX Certifications — VCF blog, 31 Aug 2026Tier 1 — Official
- Broadcom Education — VCDX Application and DefenseTier 1 — Official
- VCF 9.0 and 9.1 Official Documentation HubsTier 1 — Official
- VCF 9.0 Design documentationTier 1 — Official