Test Automation and Sequencing in an AI-Driven World: Optimize Your Application for Greater Performance and Reliability

Engineers often spend too much time developing sequencers instead of developing test code, slowing down deployment and test execution. As requirements grow, sequencing and supporting code turn into a second codebase. Typical work shifts from new measurements to maintaining infrastructure. Operations such as step execution, configuration, test system deployment, error handling, logging, and reporting must all be developed and maintained to ensure continued test productivity. Shifting focus away from test execution and into test management reduces productivity, slows replication to new stations, and increases risk. Any small changes in test orchestration can break an otherwise stable measurement code. 

Another challenge that is often overlooked is not enough time or effort spent on the test management infrastructure—leading to repetitive development in later stages. Take, for example, a validation team that may only have simple automation needs. When transitioning from validation to production, the executed tests will likely have overlap. If the test infrastructure is misaligned, it can lead to needless redevelopment of existing test code and automation that could have otherwise been carried over to the next stage of product development.

A sequencer is the control layer that defines test flow, such as step order, branching, limits/decisions, error handling, report generation, and resource use (instruments, DUT connections, file directories, and so on). In design and validation, teams usually start with interactive measurements to get “first trace” quickly, then add automation as soon as the workflow repeats. These steps outline a common progression: 

1. Interactive bring-up—Teams use soft front panels and configuration-driven tools to confirm wiring, signal integrity, instrument settings, and basic DUT behavior. An example of how teams might execute this step could be using NI InstrumentStudio™ software for taking measurements with PXI instrumentation. 
2. Lightweight automation—Lightweight automation can be handled at the application level with built-in, no-code automation sequencing tools that sequence a set of measurements or sensors. If custom measurements or analysis are required at this point, teams might typically bring in NI LabVIEW or other coding applications for repeatable tests and procedures. The goal of this step is repeatability and faster iteration, not a full test management framework.
3. Full test management/sequencer—After an application requires variants, test outcome branching, parallel execution, operator workflows, standardized reporting, or multi-station deployment, sequencing becomes its own requirement. At this point, code is used for measurement modules that are then orchestrated into a sequencer such as NI TestStand. A sequencer like TestStand keeps flow control, results handling, and other operations from sprawling into each test code module.

Basic sequencing can be handled in interactive applications for simple linear automation flows. Software like InstrumentStudio and NI FlexLogger, which offer codeless test automation tools, would be examples of this type of interactive application.

For example, imagine you need to validate a device under test (DUT). In InstrumentStudio, you can automate a set of repeated steps in a sequence such as configuring your instrument to generate a known signal, measuring the DUT’s response and capturing the results. This repeatable sequence enables you to quickly rerun the same process on the same or multiple devices, ensuring consistency and saving time compared to manual operation—without the need for additional code. It is important to note, however, that this type of sequence is typically linear and only runs the same steps in the same order for every device. For extended sequence flow control, specialized process models, or customized UI and reporting, you would need a more advanced sequencing tool. Sequences built in InstrumentStudio are saved as a sequence file that can also be opened in TestStand for extended test management functionality.

Refer to Table 1 for a more detailed list of what can and cannot be accomplished using the InstrumentStudio sequencer.

Note: The InstrumentStudio sequencer requires an InstrumentStudio Professional license, which is also included in the LabVIEW+ Suite.

To learn more about the InstrumentStudio sequencer, visit the InstrumentStudio sequencer tool documentation page. 

Figure 1. InstrumentStudio Sequencer

Another example of no-code automation sequencing is automating the logging for the output response of a sensor module using FlexLogger. FlexLogger offers a sequencing plug-in to automate data logging of a DUT, including initialization of a data acquisition device, applying stimulus signals to the DUT, and logging data for a defined duration in a linear sequence. This plug-in enables linear step-based sequence execution, basic step-level branching (skip, repeat, stop, or jump to step), and polled conditional logic (start, stop, preconditions, and post-step actions), enabling automation of test procedures without the need for developing code.

Table 2 provides a more detailed list of what can and cannot be accomplished using the FlexLogger sequencing plug-in.

Note: The sequencing plug-in for FlexLogger requires a FlexLogger Professional license, which is also included in the LabVIEW+ Suite.

To learn more about the Sequencer Plug-In, visit https://github.com/ni/niflexlogger-plugins/tree/main/PDK%20plugins/Output%20Sequencer

Figure 2. FlexLogger Sequencing Plug-In

Complex sequencing adds variability (data-driven parameters), retries/skip logic, parallelism (multi-UUT, multi-site), resource arbitration, and traceability. Complex sequencing capabilities are crucial in validation and production because they enforce repeatable execution across stations, variants, improve throughput using advanced process models, define deterministic behavior, and produce consistent tracing/reporting for debugging and auditing of results.

A functional production test using TestStand, for example, might run the same core measurement steps for multiple product variants and multiple units under test (UUTs), while adapting parameters and flow based on a configuration file or scanned part number. The sequence can initialize shared resources, such as PXI chassis, power supplies, or fixtures, then execute per-UUT test threads in parallel while locking instruments that cannot be shared. If a measurement fails, the sequence can apply conditional branching, such as running a diagnostic sub-sequence or jumping to a safe shutdown, and it can capture standardized results in a traceable report with serial number, limits, operator ID, and calibration metadata. This process ensures that every station produces consistent data for debugging and auditing sequence outcomes.

Figure 3. TestStand Sequencer Editor

The LabVIEW+ Suite covers sequencing at multiple levels, depending on where you are in the development workflow. 

• InstrumentStudio offers interactive bring-up and scripted run control for compatible hardware and measurements. You can use it to define instrument configurations, stimulus/response setups, and repeatable measurement runs without developing a full sequencer. Sequences created in InstrumentStudio can be opened and expanded on in TestStand. 
  
• FlexLogger enables configuration-driven test execution for sensor/DAQ-centric systems. You can use it to define channels, scaling, logging, and test run configurations, so teams can repeat procedures without building a custom framework.  
  
• LabVIEW is used for more complex measurements or custom analysis as modular VIs that can be called from higher-level sequence tools. LabVIEW also enables you to expand the functionality in InstrumentStudio or FlexLogger using plug-ins. (Creating plug-ins requires a professional license for InstrumentStudio and FlexLogger.) 
  
• TestStand offers a robust sequence engine that handles complex automation such as variable-based branching, parallel/multi-UUT execution, operator UI, deployments, and standardized reporting/traceability. TestStand makes full use of measurement code written not only in LabVIEW, but a variety of other languages including C/C++, Python, .NET, and more.  
  
• The LabVIEW+ Suite supports the development workflow by allowing teams to start with configuration driven execution and codeless test automation tools, which can promote orchestration to TestStand as complexity grows, without rewriting core measurement code. 

This section outlines three distinct strategies for organizing automated test sequences based on your specific project requirements. Choosing the right approach depends on balancing your needs for setup speed, scalability, and long-term maintenance.

When to Use Basic Sequencing

Use codeless test automation tools like FlexLogger or InstrumentStudio when the flow is straightforward and you want fast bring-up without building a framework. These products are a best fit for bench validation and characterization—repeatable runs where reporting and traceability needs are minimal.

No-code automation sequencing simplifies automation that’s often done using a scripting language such as Python, which can now be done at the application level, reducing the amount of code that needs to be written and validated.

When to Use a Test Management Framework

Switch to TestStand when you need to coordinate several stations, make frequent changes, require an operator interface, need standardized reporting, support multi-UUT or parallel execution, or must meet compliance and traceability requirements. In these cases, keep measurement code modular, and move flow control, results handling, and deployment concerns into the sequencer, so orchestration does not sprawl into each test module.

The main use case for a test management framework is undoubtedly in production test environments where high volume, high throughput, and test traceability are a requirement. However, test management applications can find a place within the validation stages of test as well. Take, for example, when a high-volume of validation and/or characterization tests need to be run, the limitations of a simple sequencer will quickly become apparent, particularly in languages such as Python that lack speed optimization. Additionally, there can be a gap between the validation and production cycles, where code may need to be rewritten to be more optimized for production test. Using TestStand in both validation and production ensures that validation teams are well-equipped for situations requiring high-volume tests and a smoother transition to production stage of development.

When to Build a Custom Sequencer

Develop a custom sequencer only when your requirements are stable, and you can commit to long-term ownership (maintenance, documentation, onboarding, and automated deployment/updates). Outside of basic sequencing, the cost of ownership is often significant compared to using proven, maintained sequencing tools.

NI software lowers risk when you need integrated hardware support, maintained execution engine, deployment tooling, and built-in reporting/traceability. Open-source software can work if your team owns the framework long-term, and your requirements (hardware mix, reporting, deployment) are simple, linear, and stable. However, outside of basic sequencing, ownership of a custom framework induces a significant cost of ownership in development and maintenance, and these can already be handled within NI software such as InstrumentStudio and FlexLogger. 

Additionally, TestStand as part of the LabVIEW+ Suite offers unmatched test performance, when compared to the slower execution optimization of Python, and less sequencer development complexity compared to developing in C or .NET. TestStand offers a complete test management framework that we have optimized and maintained over decades, to save engineers the effort of having to redevelop the same solution that’s already available off the shelf.

AI accelerates test sequencing development. Many developers use AI to generate measurement code, analyze test data, and even create simple leaner sequences in their preferred languages. NI Nigel™ AI is integrated directly into the LabVIEW+ Suite, so you can take advantage of Nigel AI for all of these and more. Nigel AI with the LabVIEW+ Suite offers several benefits over other AI solutions. 

Nigel is trained specifically for test and measurement applications and can provide insights into how to use LabVIEW, InstrumentStudio, FlexLogger and TestStand to help you learn and get started faster. Nigel provides guidance on which functions and setting to use and will soon be able to generate a full TestStand sequence from a prompt—just like you might do in Python or C—in a fully developed test management framework for added robustness.

Test sequencing is a core part of test management because it defines how measurements are executed, including step order, branching, limits/decisions, error handling, and results logging/reporting. As test coverage and application complexity grow, sequencing and supporting infrastructure can quickly turn into a second codebase that slows deployment and increases risk. 

Using the LabVIEW+ Suite, you can scale automation without pushing orchestration, reporting, deployment, and traceability into every measurement module by using the simplest sequencing approach that meets today’s needs with InstrumentStudio or FlexLogger, while planning a clear path to a dedicated test management framework with TestStand as requirements expand from validation into production. Plus, Nigel AI offers comprehensive AI assistance and future orchestration of sequencing development by giving full hardware and software insights, and soon-to-be implemented sequence generation to bring your automation to the next level.

• Learn more about the LabVIEW+ Suite
• Get started with a free trial
• Request a LabVIEW+ Suite demo