- What a CLD Actually Is
- Who Issues It and How the Exam Is Delivered
- The Practical Format: Build an Application in Four Hours
- How the 40-Point Rubric Works
- The Ten Exam Topics in Plain Language
- Architecture Patterns You Must Know Cold
- Eligibility, Experience, and Validity
- Who Hires CLDs and What the Credential Signals
- Sequencing Your Preparation by Topic
- Frequently Asked Questions
- CLD means Certified LabVIEW Developer, a National Instruments credential proving you can build a working LabVIEW application from a specification.
- The exam is a four-hour practical build, not a multiple-choice test, and covers software development only without hardware.
- Grading uses a 40-point rubric: Programming style 15, Functionality 15, Documentation 10. Passing is 28/40 (70%).
- Built-in LabVIEW Help, examples and templates are allowed; externally developed VIs and resources are prohibited.
What a CLD Actually Is
CLD stands for Certified LabVIEW Developer. It is a professional credential issued by National Instruments (NI) that verifies you can design, build, document, and test a LabVIEW application on your own. It sits at the developer level of NI's certification track, above the associate-level entry credential and below the architect level.
The key word is developer. Many people know LabVIEW well enough to modify an existing project or wire up a quick data-acquisition script. The CLD asks for something different: starting from a written specification and finishing with a clean, working, readable application that another engineer could pick up and maintain. If you have seen other pages on this site, such as our overview of what CLD certification is, this article goes deeper into how the credential actually works and what it demands.
Who Issues It and How the Exam Is Delivered
The certifying body is National Instruments Corporation. Exam scheduling currently runs through Pearson VUE, and NI also supports an OnVUE online-testing route so that candidates can sit the exam remotely. Performance-based exams like this one are delivered on a secured virtual machine, which means the software environment you work in is assigned to you rather than being your own installation.
One practical caution: NI's older preparation guide (document 100900A-01, copyright 2012) describes delivery logistics such as USB drives, specific software versions, and local proctors. Those details are historical. Always confirm the assigned software image and candidate rules through the current booking instructions on the NI and Pearson VUE pages rather than relying on the old guide's logistics section. For scheduling windows and deadlines, see our guide to CLD exam dates, and for the money side, the CLD certification cost breakdown.
The Practical Format: Build an Application in Four Hours
This is the single most important fact about the CLD, and the one candidates most often misjudge. The initial CLD is an application-development practical examination. You are given a specification and four hours to build a working LabVIEW application that satisfies it. There is no multiple-choice question bank standing between you and the credential, and there is no published count of exam items, because the exam is not item-based in that sense.
Key format facts:
- Duration: four hours, from specification to finished application.
- Scope: software development only. The exam does not require physical hardware; you build and demonstrate the application in software.
- Allowed resources: LabVIEW's built-in Help, shipped examples, and templates are permitted.
- Prohibited resources: externally developed VIs or outside resources may not be used.
- Output: a working VI hierarchy that is then graded against a written rubric.
Because the format is hands-on, the difficulty is different in kind from a knowledge test. Time management, architecture choices made in the first twenty minutes, and the discipline to document as you go matter as much as raw LabVIEW fluency. Our difficulty guide covers how candidates experience that pressure.
How the 40-Point Rubric Works
Your application is evaluated against a 40-point rubric defined in NI's CLD preparation guide. The categories and points are:
| Rubric Category | Points | Share of 40-Point Rubric |
|---|---|---|
| Programming style | 15 | 37.5% |
| Functionality | 15 | 37.5% |
| Documentation | 10 | 25% |
| Total | 40 | 100% |
The passing criterion is 28 out of 40 points, which is 70%. For a closer look at what that threshold means in practice, read our CLD passing score guide.
Two clarifications prevent common misunderstandings:
- These percentages are shares of the grading rubric. They are not weights for the ten exam topic areas listed in the next section. NI does not publish percentage weights for those ten topics.
- Programming style and Functionality carry equal weight, and together they make up three-quarters of the rubric. A candidate who builds something that technically runs but is sloppy, hard to read, or poorly structured gives away a large share of the available points.
Key Takeaway
Documentation is worth 10 of 40 points, a quarter of the rubric, yet it is the category candidates most often rush at the end. Document as you build: label controls, write VI descriptions, and add block diagram comments while the design is fresh, then use any remaining time for polish.
The Ten Exam Topics in Plain Language
NI's preparation guide lists ten exam topics that describe the knowledge behind the practical build. They have no published percentage weights, so treat them as a checklist of competencies rather than a scoring formula. Our complete guide to the ten content areas walks through each in detail; here is the working summary.
Domain 1: Design Concepts
The foundation of everything else. Candidates must understand what makes an application well designed.
- Modularity, scalability, readability, and maintainability
- Cohesion and coupling between components
- Hierarchical and file-level design organization
Domain 2: User Interface Design
The front panel is part of the deliverable and is graded as such.
- Color, grouping, and control properties
- Custom objects and icons
- Static and dynamic state of controls at initialization and at stop
Domain 3: Block Diagram Layout and Style
Readable code is rewarded and tangled code is penalized.
- Data flow that reads clearly left to right
- Diagram readability and tidy wiring
Domain 4: Programming Practices
Choosing the right building blocks.
- Data elements, functions, and subVIs
- Structures, references, and property nodes
Domain 5: SubVI Design Practices
Reusable, well-formed subVIs.
- Modular subVI, front-panel, connector pane, and icon design
Domain 6: Architecture Selection
Picking a structure that keeps the application responsive and maintainable. See the next section for specifics.
Domain 7: Timing
Controlling when things happen without freezing the application.
- Timing functions and event or synchronization timeouts
- Timed structures and timing Express VIs
Domain 8: Error Handling
Errors must be detected, propagated, and reported rather than ignored.
Domain 9: Documentation
Documenting at three levels.
- Front-panel documentation
- Block-diagram documentation
- VI properties documentation
Domain 10: Testing
Proving the application works.
- Code and documentation review
- Verifying functionality and catching errors
Architecture Patterns You Must Know Cold
Architecture Selection is where many four-hour builds are won or lost, because the pattern you choose in the opening minutes shapes everything after it. The goal is a design that is scalable, maintainable, and responsive, with nonblocking behavior so the user interface never locks up while work happens in the background.
The patterns NI's guide expects you to recognize and apply include:
- Simple state machine: sequential or conditional steps driven by a state variable.
- User interface event handler: an Event structure responding to front-panel interaction.
- Queued message handler: commands passed as messages through a queue to a processing loop.
- Producer-consumer (data or event): parallel loops decoupled by a queue so acquisition and processing do not block each other.
- Functional global variable: a non-reentrant VI that stores and serves shared data safely.
The skill being tested is judgment, not memorization. Given a specification, can you pick the pattern that fits, implement it cleanly, and avoid over-engineering? A simple state machine solves a surprising number of specifications; reaching for a heavier pattern than the problem needs costs time you will want back for documentation and testing.
Eligibility, Experience, and Validity
NI lists no mandatory prerequisite for the initial CLD, and the current credential page does not require another certification first. The older guide's mandatory associate-level prerequisite has been superseded. Our CLD requirements guide covers eligibility in full.
What NI does give is a recommendation: 12 to 18 months of LabVIEW development experience. Completing the Core 1, Core 2, and Core 3 courses can substitute for three months of that experience. Treat the recommendation seriously. The exam rewards habits that come from building real applications, and time in the editor is hard to shortcut.
Once earned, the certification is valid for three years. NI's recertification policy, updated April 30, 2026, allows renewal by examination, and it also offers Recertification by Points to developer-level and architect-level professionals. Recertification uses its own distinct examination, which should not be confused with the format of the initial CLD build.
Who Hires CLDs and What the Credential Signals
LabVIEW is the working language of test, measurement, automation, and control. The people who hire for it include test and automated-test-equipment engineering groups, manufacturing and validation teams, research laboratories, and system integrators and consultancies that build LabVIEW-based systems for clients. In those settings the CLD works as a quick, credible signal: this person has built a complete application under time pressure and was graded on style, function, and documentation, not just on recall.
That signal is especially useful for consultants and integrators who need to demonstrate competence to clients, and for engineers moving between employers who want an objective marker beside their project history. For a fuller look at the job landscape, see our page on CLD jobs. If you are weighing the investment, our ROI analysis and salary guide take a measured view of what the credential does and does not do for compensation.
Sequencing Your Preparation by Topic
Because the exam is a timed build, the most useful preparation mirrors it: repeated practice builds from specifications, scored against the same three rubric categories. One sensible ordering of the ten topics across a few weeks follows the logic of the build itself. Our full CLD study guide expands on this.
Design Concepts, Block Diagram Style, SubVI Practices
- Practice cohesion, coupling, and clean data flow on small projects
- Build subVIs with tidy connector panes and icons
Architecture Selection and Timing
- Implement each pattern at least once from scratch
- Practice nonblocking loops and event timeouts
User Interface, Error Handling, Programming Practices
- Control initialization and stop behavior on every build
- Wire error clusters through every subVI
Documentation, Testing, Full Timed Builds
- Run complete four-hour builds and self-score on the 40-point rubric
- Review each build for missed documentation and untested edge cases
If you want a condensed refresher near exam day, our CLD cheat sheet distills the must-know facts onto one page, and the pass rate discussion explains what can and cannot be said about outcomes. For hands-on exercises, head to the main CLD Exam Prep practice site.
Frequently Asked Questions
CLD stands for Certified LabVIEW Developer, a credential issued by National Instruments that verifies you can build a working, well-documented LabVIEW application from a specification.
No. The initial CLD is a four-hour practical in which you build a LabVIEW application from a specification. Conceptual questions are only supplementary preparation, not a substitute for timed coding practice.
Your application is graded on a 40-point rubric: Programming style 15, Functionality 15, and Documentation 10. You need 28 of 40 points, which is 70%, to pass.
The guide permits built-in LabVIEW Help, shipped examples, and templates. It prohibits externally developed VIs or other outside resources, so your solution must be built from what LabVIEW itself provides.
A CLD is valid for three years. NI's recertification policy, updated April 30, 2026, allows renewal by examination, and developer-level professionals can also use Recertification by Points.