FAQ

Licensing & Pricing

How is Maestro licensed?
Maestro is distributed as container images through a private GitLab registry. Access is controlled by a GitLab Personal Access Token — there is no separate license key, activation code, or per-seat fee. Contact E-Sharp AB to arrange access.

Does Maestro require an internet connection to run?
No. Once the container images are pulled and the station is running, Maestro operates entirely on your local network. Internet access is only needed to pull updated images or download test packages from a remote GitLab registry. Both can be configured for air-gapped environments using local mirrors.

Is there a per-station fee?
Contact E-Sharp AB. The deployment model is image-based — adding a station means running the installer on another machine using the same registry token.

Do I need a license for each test runner?
No. The .NET runner, Python runner, and MCP server are all part of the same station stack and covered by the same registry access.

Is the source code available?
Contact E-Sharp AB regarding source access and support agreements.

Can Maestro Do X?

Can Maestro run tests automatically without an operator?
Yes. Set unattendedMode: true in the execution request. Prompt steps auto-respond using a deterministic rule. All other steps are unaffected. See Using Maestro — Running Tests Headless.

Can Maestro run tests on a schedule?
Not natively — there is no built-in scheduler. Scheduled runs are triggered via the REST API from an external scheduler (Windows Task Scheduler, cron, GitLab CI, etc.). See Using Maestro — Scheduling Test Runs.

Can Maestro run the same test on multiple stations simultaneously?
Yes, indirectly. Each station is autonomous — running a test on station A has no effect on station B. Trigger both via the API at the same time and poll both for results. With the MCP server, an AI assistant can start tests on multiple stations in a single conversation turn.

Can Maestro run two tests on the same station at the same time?
No. A station executes one test at a time. For parallel execution on one physical host, run two separate station instances (each with their own API and Redis) pointing at the same PostgreSQL database.

Can Maestro talk to VISA instruments?
Yes, through runner code. The .NET runner uses VISA libraries (NI-VISA, Keysight IO Libraries). The Python runner uses PyVISA. Instrument addresses are stored in Station Config and injected automatically — the same YAML file runs on any station regardless of which instrument is at which address.

Can Maestro test software instead of hardware?
Maestro is designed for hardware testing on a factory floor. It can call any code from a .NET or Python runner, so it can technically invoke software systems — but features like station configuration, serial number traceability, and measurement limits are oriented toward physical testing. For pure software testing, pytest is more appropriate.

Can Maestro integrate with our MES?
Yes. Maestro has a pluggable IMesService interface with three lifecycle hooks: routing, validation, and result reporting. The default implementation allows everything through (no MES). A custom implementation can be swapped in without changing any test code. Results that cannot be posted (MES down, network issue) are queued and retried automatically.

Can Maestro send results to an external system?
Yes, in several ways: the REST API returns full execution reports and measurements; the PostgreSQL database can be queried directly; the MES integration posts results after each run; custom reporting can be triggered from CI/CD pipelines that call the API.

Can Maestro run Python tests?
Yes. The Python runner executes Python functions from packages in the python_modules/ directory. Python dependencies are declared in package.json under requirements.pipPackages and installed automatically, or vendored as wheel files for air-gapped stations.

Can Maestro run .NET Framework 4.8 / 32-bit code?
Yes. The legacy .NET runner supports .NET Framework 4.8 running in 32-bit mode. This exists specifically for instrument libraries that have only 32-bit Windows bindings. Both .NET 10 (modern) and .NET 4.8 (legacy) runners can be used in the same test sequence, with variables flowing between them through Redis.

Can Maestro be controlled from an AI assistant?
Yes. The MCP server exposes 41 tools to any AI assistant that supports the Model Context Protocol (Claude, GitHub Copilot, Cursor, and others). The AI can start tests, monitor progress, query results, and manage packages through natural language.

Can Maestro generate test reports as PDF?
The built-in report page is designed for browser printing — use Ctrl+P to print or save as PDF. The report layout hides navigation chrome when printing and is formatted for A4/Letter. For automated PDF generation, call GET /api/testexecution/{id}/report and pass the JSON to your own report template.

Can Maestro validate my YAML before I commit it?
Yes. Run py validate.py from the package directory (two-level validation: structural without a running stack, semantic with). Or paste the YAML into the Validator page (/yaml-validator) in the UI.

Can Maestro support real-time timing requirements (microsecond precision)?
No. The inter-step overhead is 5–20 ms and type: delay steps use Thread.Sleep, which has OS scheduler resolution of approximately ±15 ms on Windows. Steps that require tight timing (waveform generation, synchronised acquisition) must implement that timing entirely inside a single runner method. See How Maestro Works — Timing.

Can I import test results from another system into Maestro?
There is no bulk import tool in the current release. Results can be written directly to the PostgreSQL database if the schema is followed, but this is unsupported and may break across versions. Contact E-Sharp AB for migration assistance.

Performance Expectations

How fast does Maestro execute steps?
The inter-step overhead — variable resolution, result persistence, event broadcasting — is typically 5–20 ms per step. The total step time depends on what the runner does: a simple measurement with a well-configured instrument adds a further 5–500 ms depending on the instrument.

How many steps can a test have?
There is no enforced limit. Tests with 200+ steps work without issue. Very large tests (1,000+ steps) may produce reports that are slow to render in the browser — use sub-sequences (type: sequence) to split long sequences into logical sections.

How many measurements can one step record?
No limit. A step that reads 20 power rails and returns 20 measurements records all 20 in a single gRPC response.

How many executions per day can a station handle?
Execution throughput depends on test duration, not on Maestro overhead. A test that takes 30 seconds runs a maximum of ~2,800 times per day on a single station. Maestro's per-execution overhead is negligible compared to instrument communication time.

How large does the database get?
At 100 steps per execution, 10 measurements per step, and 500 executions per day, the measurements table grows by approximately 500,000 rows per day. PostgreSQL handles this volume well with proper indexing. Plan a retention or archival strategy before the table reaches 50 million rows. See Best Practices — Archival Planning.

How many stations can share one PostgreSQL database?
Practically, dozens. PostgreSQL is the shared bottleneck, and the query pattern is write-heavy (step results being inserted during tests). On commodity hardware, a PostgreSQL instance can comfortably serve 20–30 simultaneously running stations. Beyond that, consider read replicas for analytics queries to relieve write pressure.

Does Maestro's web UI add latency to test execution?
No. The UI receives SignalR events but does not sit in the execution path. A test runs at the same speed whether zero or twenty browser tabs are watching it. Opening more browser tabs consumes server-side SignalR broadcast resources but does not slow step execution.

Security & Data Handling

Where is test data stored?
All test results, measurements, logs, and configuration are stored in PostgreSQL on your infrastructure. No data is sent to Anthropic, E-Sharp AB, or any third party. Maestro is entirely self-hosted.

Is the REST API authenticated?
Not by default. The current release ships with a permissive AllowAllPermissionService — any client that can reach the API port can call any endpoint. The IPermissionService interface is already wired throughout the codebase; an authenticated implementation (AD/LDAP/OAuth) can be swapped in without changing calling code. Enforce access control at the network layer (VLAN, firewall, VPN) until API-level auth is enabled in your deployment.

Is data encrypted in transit?
Not by default. Production deployments should terminate TLS at a reverse proxy (nginx, Caddy) in front of the Maestro UI and API. The MCP server also benefits from TLS if accessed over an untrusted network.

Is data encrypted at rest?
PostgreSQL and Redis do not apply encryption at rest by default. Use encrypted volumes (BitLocker, dm-crypt) at the OS or storage level if data-at-rest encryption is required.

Who can see test results?
In the default (unauthenticated) deployment, anyone with network access to the API or UI port can search and view all test results. Restrict network access to authorised users until role-based access control is enabled.

Are GitLab Personal Access Tokens stored securely?
The PAT used to authenticate package operations is stored in the PostgreSQL database — not in any file, .env, or container environment variable. The PAT used for Docker image pulls during installation is not persisted anywhere after install.

Does the MCP server send test data to an AI provider?
The MCP server itself does not transmit data to any external service. When you use the MCP server with an AI assistant (Claude, Copilot, etc.), the AI client sends your conversation and tool results to the AI provider per that provider's data handling policy. No data is sent until you explicitly ask the AI assistant to call a Maestro tool.

Can we run Maestro in an air-gapped environment?
Yes. Once images are pulled, Maestro runs without internet access. Test packages can be distributed via a local GitLab instance or by mounting package directories directly. Wheel files for Python dependencies can be vendored in the package's wheels/ directory.

Does Maestro log personally identifiable information?
Operator IDs are recorded on every execution record (as entered — Maestro does not validate their format). If operator IDs are employee numbers, email addresses, or other PII, they are stored in PostgreSQL in cleartext. Configure a data retention policy appropriate to your GDPR or other regulatory obligations.

Deployment Models

Can I run Maestro on a single machine?
Yes. The all-in-one Docker Compose stack runs everything on one machine — PostgreSQL, Redis, API, UI, and runners. This is the recommended starting point for evaluation and single-bench labs.

Can multiple stations share one database?
Yes. This is the standard production deployment. A central server runs PostgreSQL and the fleet dashboard; each station runs its own API, UI, and runners, all writing to the shared database. See Installing and Setting Up — Deployment Topologies.

Can I run Maestro in the cloud?
Yes, with caveats. The central server (PostgreSQL + dashboard) can run in a cloud VM with no issues. Station instances that communicate with physical instruments must run on or near the test station — network latency to cloud-hosted runners adds to instrument round-trip time and may cause timeout issues for fast instrument interactions.

Can I run Maestro on a Raspberry Pi?
Yes — the 64-bit Raspberry Pi OS is supported. The 32-bit (armhf) image is not supported because .NET 10 requires arm64. All Maestro container images are published as multi-arch manifests covering linux/amd64 and linux/arm64.

Can I run Maestro on Windows without Docker?
For development, the API and UI can be run with dotnet run without Docker. For production, Docker is strongly recommended — it ensures consistent behaviour across stations and simplifies upgrades. The .NET 4.8 runner must run on Windows (it is not containerised).

Can I run Maestro behind a corporate proxy?
Yes, with standard Docker proxy configuration. Set HTTP_PROXY, HTTPS_PROXY, and NO_PROXY in the Docker daemon config and in the container environment for any step that makes outbound network calls.

How do I update Maestro?
docker compose pull && docker compose up -d on each station. Database migrations apply automatically on API startup. Always update the central server (and run migrations) before updating stations. See Installing and Setting Up — Upgrading Maestro.

Can different stations run different versions of Maestro?
With caution. A station running a newer version than the database schema expects will fail to start (migrations not yet applied). A station running an older version than the database can work, but may miss new features or encounter schema additions it does not understand. The recommended upgrade path: update central server first, then stations.

Typical Questions from New Teams

We're replacing NI TestStand. How is Maestro different?
The core difference is that Maestro uses YAML files in Git instead of proprietary .seq files in a GUI editor. Your test definitions are text files — diffable, reviewable, branchable, and version-controlled like any other source code. Instrument logic lives in standard .NET or Python code rather than in TestStand's scripting model. See How Maestro Works for a full architectural comparison.

We already use pytest for hardware testing. Why switch?
You may not need to switch entirely. pytest is an excellent tool for testing software and for unit-testing the Python functions you deploy into Maestro runners. Maestro adds the layer that pytest does not provide for factory-floor testing: station configuration management, serial number traceability, operator UI, structured measurement storage, and fleet monitoring. See How Maestro Works — Software Testing vs Manufacturing Testing for a detailed comparison.

How long does it take to get a first test running?
Starting from a fresh install: running docker compose up -d, loading the example package, and executing a test typically takes under 30 minutes. Writing your first real test — connecting to an instrument, making a measurement, and getting a result with a verdict — typically takes a day for a developer who is new to Maestro.

Do operators need training?
Basic operation (selecting a package, entering a serial number, clicking Run, reading the verdict) is designed to be self-evident for someone who has never used Maestro. Operator prompts display clear instructions. The UI does not expose configuration or code. A 30-minute walkthrough is usually sufficient for factory operators.

How do we handle test packages across multiple product lines?
Each product line gets its own package repository. The catalog registry lists all packages with their supportedProductIds metadata. Operators browse the catalog and select the package for their current product. Packages for different products are fully isolated — separate Git repositories, separate YAML, separate runner assemblies.

Can we have development, staging, and production environments?
Yes. The typical pattern is three separate station stacks (or three separate PostgreSQL databases) representing dev, staging, and production. Test packages are promoted through lifecycle stages: NotReleased on dev stations, Evaluation on staging, Released on production. The package version and Git commit hash on every execution record make it straightforward to trace which version was running in which environment.

What happens if the database goes down during a test?
Tests that are already running continue executing — the execution state is managed in the API process and Redis, not in PostgreSQL. Step results that cannot be persisted are queued in memory. When the database recovers, pending writes are flushed. If the API restarts before recovery, in-progress results may be lost. Completed tests that were fully written before the outage are unaffected.

Can we back up and restore Maestro data?
Yes. All persistent data is in PostgreSQL — use pg_dump for backups and psql for restore. Redis is ephemeral (variable bus only) and does not need to be backed up. Test packages are in Git and are their own backup. See Installing and Setting Up — Backing Up and Restoring.

Is there a staging environment we can test against before going to production?
Maestro does not provide a shared cloud staging environment. You provision your own staging station (or a station that points at a staging database) using the same installer as production. This ensures staging is identical to production in every way that matters.

What support is available?
Contact E-Sharp AB through your account contact. For self-service, this documentation covers the majority of operational scenarios. The troubleshooting guide is the first stop for error messages and unexpected behaviour.