An automotive supplier whose product contains a microcontroller isn’t questioned only on tooling and process control in an IATF 16949 audit. The auditor asks how the software in that microcontroller was developed, which version was built with which tool and whether the correct file was flashed at the end of the line. Most of these questions are answered not by the quality department but from the shared ground of IT and the software team, who run the code repository, build server and programming station. Below we cover in turn what the standard requires, how it relates to Automotive SPICE and the points where gaps can appear.
Which companies does the requirement cover?
IATF 16949:2016 has two clauses directly related to embedded software. 8.3.2.3 (Development of products with embedded software) is aimed at an organization that develops the software in its product in-house: it requires a process for software quality assurance, the development process to be assessed using an appropriate assessment methodology, a self-assessment prioritized on the basis of risk and potential impact on the customer to be retained as documented information, and software development to be included in the internal audit program. 8.4.2.3.1 carries the same expectation into the supply chain: it requires sub-suppliers that supply automotive product-related software or products with embedded software to also run a quality assurance process, assess their processes with a methodology and retain a risk-based self-assessment themselves.
| Status | Relevant clause | Expected |
|---|---|---|
| ECU software is written in-house | 8.3.2.3 | Process, self-assessment, internal audit |
| Software is commissioned from a design house | 8.4.2.3.1 | Process requirement on the supplier and monitoring |
| An off-the-shelf module is bought with its own software | 8.4.2.3.1 | Evidence of process and self-assessment at the supplier |
| Software/parameters are flashed at the end of the line | 8.3.2.3 and 8.5 | Checking that the correct version was flashed |
Draw the boundary clearly from the start. Software used in production, such as a test stand, CMM or SPC tool, isn’t part of the product; validating it is a separate topic, explained in the guide validating measurement and test software. The topic here is the software that goes to the customer with the vehicle. In the field, the two scopes are often confused. The result is two half-finished files.
What should the software quality assurance process include?
The standard doesn’t list process steps one by one; the phrase “quality assurance process” is read together with the assessment methodology. What the auditor looks for in practice is evidence that the software moves through a controlled lifecycle from requirement to delivery and that this lifecycle is monitored with an independent eye. The minimum components are:
- Requirements management: Traceability from customer requirement to software requirement; each requirement is mapped to a verification status.
- Architecture and detailed design: Component boundaries and interfaces are documented; the reasoning behind decisions with security or functional safety impact is written down.
- Verification: Unit testing, integration testing and software qualification testing; static analysis and coding standard (for example MISRA C) compliance are reported.
- Release approval: A signed release decision showing which test was run against which build.
- Configuration, problem and change management: Support processes and records that cut across every stage of development.
- Quality assurance: A role independent of the project team periodically checking process and product conformity and following up deviations until they’re closed.
The last item is the one most often missing in audits. Small teams may not have a separate software quality engineer. In that case, a senior developer from another project doing a cross-review and the findings being recorded shows independence to a reasonable degree. A review with no record is treated as not done.
Automotive SPICE and self-assessment
The standard doesn’t impose a specific model; it asks for “an appropriate assessment methodology”. In automotive, this need is largely met by the Automotive SPICE process assessment model published by VDA QMC; some organizations use alternatives such as CMMI. Which model and which target level are expected is often written in customer-specific requirements (CSRs). Read the relevant OEM’s CSR document before starting the self-assessment; changing the model later doubles the work.
Automotive SPICE defines processes in groups: system engineering (SYS), software engineering (SWE), support (SUP), management (MAN) and acquisition (ACQ) are the ones most often assessed. Each process is rated on a capability level from 0 to 5; process attributes are scored on the scale N (not achieved), P (partially), L (largely) and F (fully). Level 1 shows the process achieves its purpose, level 2 that the process and work products are managed, and level 3 that an organizationally defined standard process is used.
A self-assessment isn’t a formal assessment. But it can’t be a casual survey either. A workable order is:
- Draw up a list of projects prioritized by risk and customer impact; safety-related or high-volume products come first.
- Set the scope: which processes, which target level. If the set of processes the customer wants is known, use it as the basis.
- For each process, compare base practices and work products with the actual records in the project; back up interviews with evidence.
- Record the ratings as N/P/L/F and turn gaps into actions with owners and dates.
- Feed the result into management review and the internal audit program.
Configuration and release management
When a fault is reported from the field, the first question is: exactly which software was in the ECU in this vehicle, and from which source and with which tools was it produced? Being able to answer this question within minutes is the real purpose of configuration management. If the answer takes days, the process exists only on paper. A release baseline doesn’t consist of source code alone:
- Source code and build scripts (with the commit ID)
- Compiler, linker and library versions and build options
- Calibration and variant parameter files
- The binary produced (hex/bin) and its hash
- Test reports and release notes
Signing the release tag and recording the binary’s hash is the simplest way to prove that the file going to the programming station is the approved file:
# Mark the approved release with a signed tag
git tag -s v2.4.1 -m "ECU-X software release 2.4.1 - release approval SR-0412"
git verify-tag v2.4.1
# Generate the binary’s SHA-256 hash and add it to the release record
sha256sum ecu_x_2.4.1.hex > ecu_x_2.4.1.hex.sha256
# Verify on the programming station before flashing
sha256sum -c ecu_x_2.4.1.hex.sha256
End-of-line software flashing is where development and production intersect, and where the auditor goes into detail. Where does the programming station get the file from, who can change that file, and is the version read back from the ECU after flashing recorded together with the part serial number? A gap you may come across is a file copied by hand onto the station’s local disk and no flashing record at all. A file change on the station is a production change; its classification must be consistent with the process in the guide change management in production systems.
Managing the development toolchain and code repository
Embedded software teams often choose and install their tools themselves. But the servers these tools run on, license servers, backup and access management are IT’s job. If the boundary of responsibility isn’t written down, in an IT compliance audit the question “Who does this?” falls between the two teams.
| Field | IT responsibility | Development responsibility |
|---|---|---|
| Code repository (Git server) | Hosting, backup, access, authentication | Branching strategy, review rules |
| Build servers (CI) | Operating system, patching, capacity | Pipeline definition, tool versions |
| Compiler licenses | License server continuity | License needs and version selection |
| Tool archive | Long-term retention and restore testing | Defining the toolset to be archived |
| Release files | Secure distribution to the programming station | Release approval and hash |
The row most often overlooked in the table is the tool archive. Automotive parts are produced as spare parts for years after series production, and a software fix may be needed in the field. If that compiler version, its license and the operating system it runs on are lost, you can’t reproduce the same binary. Source code alone isn’t enough. The practical solution: archive the build environment for each major release as a virtual machine or container image, put the installation files and license information alongside it, and at least once a year build from this environment and verify that you get the same hash. If the license server is tied to a MAC address or hardware dongle, write this dependency into the archive note too; that’s where restoration gets stuck first.
In projects within functional safety scope, the confidence in software tools section of ISO 26262-8 (tool confidence level, TCL) also comes into play: tool classification and, if needed, tool qualification evidence are required for code generators, static analysis and test tools. When a tool’s version changes, the validity of this evidence is reassessed. That’s why a tool update shouldn’t be treated as a routine patch on the IT side; turning on automatic updates on the build server means silently replacing a qualified tool.
The minimum controls in the code repository are: a protected main branch and mandatory code review, authentication with personal accounts and multi-factor authentication, closing leavers’ access on the same day, backing up the repository and CI configuration and recording restore tests. A repository pushed to with a shared “build” account can’t prove who changed what. If customer-provided specifications or OEM-owned code fragments are in the repository, they’re also customer property, and access restrictions are planned accordingly.
Evidence expected in the audit
The list below gathers the evidence that should be ready under 8.3.2.3 and 8.4.2.3.1. To combine it with general IT evidence, the list in the guide IT evidence in the IATF 16949 audit can be used.
- Software development process definition and role definitions (including the quality assurance role)
- The chosen assessment methodology, its justification and its match with the customer CSR
- A risk-based, prioritized self-assessment report and action plan
- An internal audit plan covering software development and the latest audit report
- A requirements–test traceability matrix for a sample release
- Release approval record, signed tag and binary hash
- Tool list, versions and a record of the tool archive’s restore test
- Contract terms and monitoring records for software sub-suppliers
- Code repository access list and a periodic access review record
Mistakes you may come across
Doing the self-assessment once and forgetting it: The standard requires the self-assessment to be retained as documented information. A report that isn’t updated when the process changes or when a new customer or product family arrives doesn’t answer the auditor’s question, “Is this still valid?”
Leaving software out of the internal audit: If internal auditors in the quality department aren’t familiar with software processes, this area is silently skipped. The clause explicitly requires it. The solution is to add an auditor with software knowledge to the team during IATF 16949 audit preparation, or to plan an outsourced internal audit.
Keeping the end-of-line programming file in a shared folder: A file flashed from a network folder everyone can write to can’t prove it’s the same as the approved release. Read-only distribution, hash checking and a flashing record are set up together; if one is missing, the chain breaks.
Treating a sub-supplier’s software as a black box: 8.4.2.3.1 also requires a quality assurance process and a supplier self-assessment for purchased software. In addition to the self-assessment summary, release notes, a test summary and the release ID should be requested and recorded at incoming quality inspection.
Managing embedded software requirements in a single program together with code repository and access controls under TISAX and ISO 27001 lets the same evidence be used in several audits; the framework is described on the integrated TISAX, ISO 27001 and IATF program page. For the standard’s official text and interpretations, IATF Global Oversight is the primary source, and for the Automotive SPICE model, VDA QMC.
Frequently asked questions
Is an Automotive SPICE certificate mandatory for IATF 16949?
No. IATF 16949 requires the software development process to be assessed with an appropriate methodology and the self-assessment to be retained; it doesn’t require a specific model or a formal assessment. However, many OEMs explicitly state Automotive SPICE and a target capability level in their customer-specific requirements. In that case, the customer requirement is binding.
We have our software developed entirely by an external design firm; does 8.3.2.3 apply to us?
If the software isn’t developed in-house, the self-assessment obligation of 8.3.2.3 may not apply directly; instead, 8.4.2.3.1 comes into play. You need to write into the contract that the design firm runs a software quality assurance process and retains its own self-assessment, and monitor this. Writing the requirements, accepting the release and managing field problems are still your job.
Does a calibration parameter change count as a software change?
Every parameter set that changes the product’s behavior is subject to configuration management and is tracked as part of the release baseline. Whether customer approval is needed is determined by the product approval process and customer requirements; this decision must be written clearly in the change record.
What should we keep to be able to rebuild an old version years later?
Alongside the source code, the compiler and library installation files, license information, build scripts and a virtual machine or container image of the build environment should be kept. That the archive works should be verified periodically by building from this environment and obtaining the same hash value.