- Who Can Sit the CLD Exam
- The 12-18 Month Experience Recommendation
- What You Are Qualifying For: The Four-Hour Practical
- The 40-Point Rubric and the 28-Point Bar
- The Ten Exam Topics You Must Be Ready For
- Registration and Delivery Logistics
- What You May and May Not Use During the Exam
- A Requirements-Driven Readiness Plan
- Validity, Recertification and Staying Qualified
- Outdated Requirement Claims to Ignore
- Frequently Asked Questions
- NI lists no mandatory prerequisite for the Certified LabVIEW Developer exam, but recommends 12-18 months of LabVIEW development experience.
- Core 1, Core 2 and Core 3 together may substitute for three months of that recommended experience.
- The exam is a four-hour practical: you build a working LabVIEW application from a specification, software only.
- Passing requires 28 of 40 rubric points (70%): Programming style 15, Functionality 15, Documentation 10.
Who Can Sit the CLD Exam
The Certified LabVIEW Developer (CLD) credential, issued by National Instruments Corporation (NI), has an unusually open front door. NI lists no mandatory prerequisite for the initial exam. You do not need a prior certification, a degree, a training-course transcript or a letter from an employer. In principle, anyone who can book the exam can attempt it.
That openness is easy to misread. The absence of a formal gate does not mean the exam is entry level. The CLD is a hands-on practical in which you must produce a working application, and the people who pass it have typically spent a long time building real LabVIEW programs. The requirement that actually matters is not paperwork but demonstrated ability to design, build, document and test an application under time pressure. For a deeper look at how demanding that is, see our breakdown in How Hard Is the CLD Exam? Complete Difficulty Guide 2026.
The 12-18 Month Experience Recommendation
NI's guidance is that candidates should have 12-18 months of LabVIEW development experience before attempting the CLD. This is a recommendation, not an enforced rule, and nobody checks your work history at the door. It is, however, the closest thing the CLD has to an official qualification standard, and it is worth taking seriously because of what the exam measures.
The experience that counts is not merely time spent with LabVIEW open. It is time spent making design decisions: choosing a structure, partitioning code into subVIs, handling errors, laying out a front panel and documenting what you built. Someone who has spent eighteen months wiring quick data-acquisition scripts may be less prepared than someone with a year of building modular applications.
How Core 1, Core 2 and Core 3 fit in
NI recognizes that structured training can accelerate your readiness. Completing Core 1, Core 2 and Core 3 may substitute for three months of the recommended experience. Notice what this does and does not say:
- It reduces the experience recommendation by three months; it does not replace it.
- It is not a prerequisite. You can skip the courses entirely and still register.
- It does not guarantee a pass. The courses teach concepts, while the exam tests whether you can apply them quickly in a complete build.
If you are weighing whether to invest in classes, our guide to CLD Certification Cost 2026: Complete Pricing Breakdown covers how training and exam expenses fit together, and CLD Training explores the preparation options available.
What You Are Qualifying For: The Four-Hour Practical
To understand the requirements, you need to understand the exam. The initial CLD is a practical application-development examination. It is not a multiple-choice test, and there is no published question count for it. You are handed a specification and given four hours to build a working LabVIEW application that satisfies it. The work is software development only, without hardware, so you will not be wiring instruments or configuring DAQ devices; you will be simulating data and demonstrating architecture.
This format shapes who is genuinely qualified. A candidate needs to be able to:
- Read a specification and extract the required functionality without missing implied requirements.
- Choose an appropriate architecture quickly rather than experimenting.
- Build modular, readable code while keeping an eye on the clock.
- Document the application as they go, not as an afterthought.
- Test and debug their own work before time runs out.
The 40-Point Rubric and the 28-Point Bar
Your work is evaluated against a separate 40-point evaluation rubric, and the passing criterion is 28 of 40 points (70%). The rubric divides as follows:
| Rubric Category | Points | Share of 40 Points |
|---|---|---|
| Programming style | 15 | 37.5% |
| Functionality | 15 | 37.5% |
| Documentation | 10 | 25% |
| Total | 40 | 100% |
These are calculated shares of the grading rubric, not weights assigned to the ten topic areas. The distinction trips up many candidates, so it bears repeating: the ten exam topics describe what you need to know, while the rubric describes how your finished application is scored. For the full score mechanics, read CLD Passing Score 2026: Exactly What You Need to Pass.
What the rubric implies about readiness
Two-thirds of the points (Programming style plus Documentation, 25 of 40) reward how you build and communicate, not merely whether the program runs. A candidate who delivers a functionally correct application with messy diagrams and no documentation can fall short of 28. Qualifying in practice means being strong across all three categories, not just competent at making things work.
The Ten Exam Topics You Must Be Ready For
NI's CLD preparation guide lists ten Exam Topics. They carry no published percentage weights, so do not assume any one is "worth more." Instead, treat them as the knowledge base that supports the practical build. A full walkthrough lives in CLD Exam Domains 2026: Complete Guide to All 10 Content Areas; here is how each connects to eligibility.
Domain 1: Design Concepts
The foundation of good application design.
- Modularity, scalability, readability and maintainability
- Cohesion and coupling between components
- Hierarchical and file-based design
Domain 2: User Interface Design
Front panels that are clear and purposeful.
- Color, grouping, properties and custom objects
- Static and dynamic state at initialization and stop
- Icons
Domain 3: Block Diagram Layout and Style
Code that another developer can read at a glance.
- Data flow and diagram readability
Domain 4: Programming Practices
Choosing and using the right building blocks.
- Data elements, functions and subVIs
- Structures, references and property nodes
Domain 5: SubVI Design Practices
Reusable, well-defined modules.
- Modular subVI, front-panel, connector and icon design
Domain 6: Architecture Selection
Picking a pattern that is scalable, maintainable and responsive without blocking.
- Simple state machine and UI event handler
- Queued message handler
- Data/event producer-consumer
- Functional global variable patterns
Domain 7: Timing
Controlling when and how fast code runs.
- Timing functions and Express VIs
- Event and synchronization timeouts
- Timed structures
Domain 8: Error Handling
Detecting, propagating and reporting errors.
- Error handling and error reporting
Domain 9: Documentation
Making the application understandable to others.
- Front-panel, block-diagram and VI-property documentation
Domain 10: Testing
Verifying your own work.
- Code and documentation review
- Checking functionality and catching errors
A practical self-check for readiness: can you explain, for each of these ten topics, what a reviewer would look for in your finished application? If you can, you are probably meeting the unwritten requirement for the exam.
Registration and Delivery Logistics
NI's current scheduling partner is Pearson VUE, and there is an NI OnVUE online-testing route for candidates who prefer to test remotely. Current NI delivery uses a secured virtual machine for performance-based exams, which is how the application-development practical is administered.
Two practical points deserve attention:
- Follow current booking instructions. The older preparation guide includes delivery details that are now historical, such as USB-based logistics, software-version specifics and local-proctor arrangements. Confirm your assigned software image and candidate rules through the current booking instructions rather than relying on the guide's older delivery notes.
- Plan your scheduling window. Availability, deadlines and testing windows are covered in CLD Exam Dates 2026: Testing Windows, Deadlines & Scheduling.
Because the delivery environment is a secured virtual machine, it is wise to practice in an environment that mimics a clean installation: no custom palettes, no personal toolkits, and default settings you cannot rely on changing.
What You May and May Not Use During the Exam
Eligibility also includes understanding the rules of engagement. The guide permits the built-in LabVIEW Help, examples and templates. It prohibits externally developed VIs or resources. That boundary defines what "qualified" looks like on test day: you should be fluent enough to use the shipped examples and templates efficiently, and disciplined enough not to depend on a personal library of pre-built code.
A Requirements-Driven Readiness Plan
If you are close to the 12-18 month mark and want to make the leap, organize the final weeks around the rubric rather than around generic review. The timeline below ties each stage to specific CLD content. For a full preparation approach, see CLD Study Guide 2026: How to Pass on Your First Attempt.
Design and architecture foundations
- Review Design Concepts and Architecture Selection first, because every later decision depends on them
- Build a simple state machine and a queued message handler from scratch, no templates
Producer-consumer, timing and error handling
- Practice data/event producer-consumer loops and UI event handlers
- Add timing functions, timeouts and a consistent error-handling approach to each build
Style, subVIs and documentation
- Refactor earlier builds: connector panes, icons, diagram layout and front-panel grouping
- Document front panel, block diagram and VI properties as you build, not afterward
Timed full builds and self-grading
- Complete full four-hour practice builds from original specifications
- Grade each against the 40-point rubric and chase the weakest category
You can complement hands-on builds with knowledge checks on our CLD practice test site. Keep in mind that conceptual questions are supplementary: they reinforce the ten topics but cannot stand in for building a working application.
Validity, Recertification and Staying Qualified
Once earned, a Certified LabVIEW Developer certification is valid for three years. NI's recertification policy, updated April 30, 2026, allows renewal by examination and also offers Recertification by Points to developer-level and architect-level professionals. Recertification by examination uses a distinct recertification exam, so you should not use it to infer the format of the initial CLD.
Planning for renewal from the start is smart: keep records of your professional LabVIEW work and training so you have options when the three-year window approaches. To judge whether the investment pays off over time, read Is the CLD Certification Worth It? Complete ROI Analysis 2026, along with CLD Salary Guide 2026: Complete Earnings Analysis and CLD Jobs for the career context.
Outdated Requirement Claims to Ignore
Older material circulating online can mislead you about what is required today. Watch for these common errors:
| Older Claim | Current Reality |
|---|---|
| A CLAD certification is mandatory before the CLD | The older guide's CLAD prerequisite is superseded; the current credential page lists no prerequisite certification |
| The exam delivery uses USB drives and local proctors | Those logistics are historical; delivery now runs through Pearson VUE with a secured virtual machine |
| The exam is a multiple-choice test | The initial CLD is a four-hour application-development practical |
| The ten topics carry percentage weights | No topic weights are published; the 15/15/10 points belong to the grading rubric |
The preparation guide in circulation (100900A-01) carries a 2012 copyright, which is why its delivery details have aged. Its exam topics and rubric remain the reference for what you must demonstrate, but its logistics should be checked against NI's current pages. If you are new to the credential and want the fundamentals first, start with What Is CLD Certification? or What Does CLD Stand For?, and see CLD Pass Rate 2026: What the Data Shows for how to think about pass-rate claims.
Frequently Asked Questions
No. NI lists no mandatory prerequisite for the initial Certified LabVIEW Developer exam. The older guide's CLAD requirement has been superseded, and the current credential page lists no prerequisite certification.
NI recommends 12-18 months of LabVIEW development experience. This is a recommendation rather than an enforced requirement, and completing Core 1, Core 2 and Core 3 may substitute for three months of that experience.
You need 28 of 40 rubric points, which is 70%. The rubric awards Programming style 15 points, Functionality 15 points and Documentation 10 points.
No. The guide permits the built-in LabVIEW Help, examples and templates but prohibits externally developed VIs or other outside resources.
The certification is valid for three years. Under NI's recertification policy, updated April 30, 2026, you can renew by examination, and developer-level and architect-level professionals can also use Recertification by Points.
In short, the formal requirements for the CLD are light, but the practical bar is real: roughly a year or more of genuine development experience, fluency across the ten exam topics, and the ability to deliver a documented, working application within four hours. Build to the rubric, practice with only the allowed resources, and confirm current logistics before you book.