Ask a software engineer who has just joined an automotive supplier what surprised them most, and the answer is rarely the C code or the microcontroller. It is the paperwork: requirement IDs, trace links, review records, verification reports, and a word that seems to explain all of it, ASPICE.
Automotive SPICE is on most automotive software job descriptions, and on my own CV next to MISRA and Coverity. Yet many engineers meet it only as a list of templates someone else chose. This post explains what it actually is, how it is built, and what its software engineering processes, SWE.1 to SWE.6, expect from you day to day. A second post will cover the system engineering group, SYS.
A note on versions. Everything here is based on the Automotive SPICE process reference and assessment model version 4.1, released by the VDA Quality Management Center on 24 August 2026. It is a small update of version 4.0 from 2023: the change history lists the removal of one machine learning base practice and editorial changes. For the SWE processes, 4.0 and 4.1 can be read the same way. Automotive SPICE® is a registered trademark of the VDA.
What Automotive SPICE is, and what it is not
Automotive SPICE is a process assessment model. SPICE stands for Software Process Improvement and Capability dEtermination. It is published by the German Association of the Automotive Industry (VDA) and used across the industry, mainly so that carmakers can judge whether a supplier’s development processes are capable of producing reliable software and systems. It is built on international standards: its process reference model was derived from ISO/IEC 12207, and the model as a whole conforms to the assessment standard ISO/IEC 33004.
Three things it is not are worth saying up front, because they cause most of the frustration:
- It is not a product certification. An assessment rates how capable your processes are, project by project. It says nothing directly about whether one ECU is safe or bug-free.
- It is not a lifecycle or a template set. The model itself says so explicitly: it does not prescribe an order of activities, and it does not define document structures. One requirements specification or ten, waterfall or two-week sprints: both can satisfy it.
- It is not a safety or security standard. ISO 26262 (functional safety) and ISO/SAE 21434 (cybersecurity) are lifecycle standards with their own requirements. Automotive SPICE often sits beside them, but it does not replace them.
The model explains this with three levels of the word “process”. Automotive SPICE lives at the top, the what: goals and expected results. Your company’s process handbook, tools and templates are the how. What your team does on Tuesday afternoon is the doing. An assessor reads your how, looks at your doing, and maps both to the what.

Two dimensions: processes and capability
The whole model rests on one idea: process capability has two dimensions.
- The process dimension says which processes are looked at: software requirements analysis, unit verification, configuration management, and so on. These are defined in the process reference model.
- The capability dimension says how well each of those processes is performed, on a scale of six capability levels, from 0 (incomplete) to 5 (innovating). Each level is measured through one or two process attributes, nine in total.
An assessment therefore does not end with one grade for the company. It ends with a capability profile: a level for each process in scope, in that project.

That is why the same supplier can be strong in configuration management and weak in unit verification, and why an assessor will say so process by process. We will come back to what each level means after looking at the processes themselves.
The process reference model
The process reference model is the catalogue of processes. In version 4.1 it contains 32 processes in 11 groups, organised into three categories:
- Primary processes are the work that turns stakeholder needs into a delivered product: acquisition and supply, and the engineering groups for systems (SYS), validation (VAL), software (SWE), machine learning (MLE) and hardware (HWE).
- Supporting processes (SUP) can be used by any other process: quality assurance, configuration management, problem resolution, change request management and, since 4.0, machine learning data management.
- Organizational processes develop assets the whole organisation uses: project, risk and measurement management (MAN), process improvement (PIM) and reuse (REU).

The process numbers have gaps, SUP.1 then SUP.8, because they were inherited from the older ISO/IEC 15504 numbering. It is not a sign that something is missing.
The plug-in idea and the VDA scope. Automotive SPICE is built so that engineering disciplines plug into a shared base. Nobody is assessed against all 32 processes. The recommended VDA scope combines a basic set of management and supporting processes with at least one engineering plug-in (SYS, SWE, HWE or MLE) and optional “flex” processes, and the sponsor of an assessment decides which apply. For a software team the relevant plug-in is SWE, usually together with the system processes it depends on. Cybersecurity engineering is covered by a separate supplement, Automotive SPICE for Cybersecurity, currently in version 2.0 from March 2025.
Anatomy of a process
Every process in the model is described with the same template, and once you can read one, you can read them all:
- Process ID and name, such as SWE.4 Software Unit Verification.
- Purpose: one sentence saying why the process exists.
- Outcomes: the observable results that must be true when the process is performed well. This is what an assessor ultimately rates at level 1.
- Base practices (BPs): the activities that typically lead to those outcomes. Each one maps to one or more outcomes.
- Output information items: the kinds of information that show the outcomes exist, each with a number such as 08-60 Verification Measure.

Two points in the model’s own text change how you should read this.
First, base practices are indicators, not a checklist. The model says so directly. An assessor uses them to look for evidence, and judges the outcomes in your context, not whether you performed BP3 on a Thursday.
Second, information items are not your documents. The model explicitly warns that there is no one-to-one relationship between an information item and a work product. “15-52 Verification Results” might be a test report, a CI dashboard export and a review protocol together, or one section of a larger document. What matters is that the information exists, is correct and can be found.
Base practices only cover level 1. Levels 2 to 5 use generic practices that apply to every process; more on those below.
Where SWE sits: inside the system V
The six SWE processes are easiest to understand as half of a V, nested inside the system V. The software team receives its input from system engineering, the system requirements (SYS.2) and the system architecture (SYS.3), and hands back integrated software that SYS.4 integrates into the system. On the left side, each SWE process refines the one above it. On the right side, each SWE process checks the result of its partner on the left.

One warning before anyone prints this on a poster: the V is a map of relationships, not a schedule. The PAM is explicit that it neither prescribes nor discourages any order of processes. A team that writes a requirement, implements it and verifies it within a single sprint can satisfy every SWE process. What it cannot skip is the consistency between the levels, which is what the dashed arrows stand for.
SWE.1 to SWE.6, one by one
The six processes are not equally large. SWE.5 alone has nine outcomes, because since version 4.0 it covers both component verification and integration verification.

SWE.1 Software Requirements Analysis
What it is for: turning the software-relevant parts of the system requirements and system architecture into a structured, analysed set of software requirements.
What an assessor looks for: functional and non-functional software requirements, structured and prioritised (for example by function, variant or release); evidence that they were analysed for correctness and technical feasibility; an analysis of their impact on the operating environment; consistent, bidirectional traceability to both the system requirements and the system architecture; and proof that the agreed requirements reached the people who need them.
In practice: the PAM’s notes are a good requirements-writing guide in themselves. They name verifiability, unambiguity, freedom from design and no contradictions as typical characteristics. Timing, memory and start-up behaviour are requirements too, not afterthoughts. And if you only develop software, with no system around it, the model lets you use the stakeholder requirements as your starting point.
SWE.2 Software Architectural Design
What it is for: an analysed software architecture, covering both static and dynamic aspects, consistent with the software requirements.
What an assessor looks for: the static structure (software components, their interfaces and relationships, the external interfaces); the dynamic behaviour (how components interact in different modes, and concurrency such as interrupts, pre-emption and multi-threading); an analysis of the architecture against technical criteria with the rationale for design decisions; traceability to the software requirements; and communication of the agreed architecture.
In practice: the analysis is where many teams are thin. The PAM’s examples are exactly what embedded engineers care about anyway: timing, RAM, ROM, EEPROM or data flash, and CPU load. A resource budget and a short “why we chose this” per major decision go a long way. The hardware-software interface, by contrast, belongs to system design (SYS.3), not to SWE.2.
SWE.3 Software Detailed Design and Unit Construction
What it is for: a detailed design for each software component, and the code of its software units, consistent with that design.
What an assessor looks for: for each component, its units with their behaviour, structure and interfaces, including valid value ranges and physical units for inputs and outputs (the PAM gives examples like 0..200 m/s); the dynamic interactions between units; units developed according to defined coding principles; traceability from code to detailed design, from detailed design to architecture, and from detailed design to software requirements.
In practice: two notes in the PAM save a lot of argument. A software unit is defined by the meaning in the application domain, not by file boundaries, so one unit can be several functions. And the coding principles expected even at level 1 are basic ones such as avoiding implicit type conversions, one entry and one exit per subroutine, and range checks; the PAM points to ISO 26262-6 for more. Traceability should not be redundant: the model asks for a sensible combination of trace paths, not every possible link.
The verification half: one shared pattern
SWE.4, SWE.5 and SWE.6 look different at first, but they share the same skeleton, which the system-level SYS.4 and SYS.5 repeat. Version 4.0 also replaced the old word test with verification measure: a test case, but equally a review, a static analysis, a calculation or a simulation.

SWE.4 Software Unit Verification
What it is for: showing that each software unit is consistent with its detailed design.
What an assessor looks for: unit verification measures with pass/fail criteria, entry and exit criteria and the required infrastructure; a documented selection of measures for the release scope, including regression; recorded results; traceability between measures and units and between results and measures; and a summary.
In practice: the PAM names static analysis, code reviews and unit tests as examples, and explicitly mentions MISRA rule sets for static analysis. A MISRA report from your static analyser, linked to the units it covers, is unit verification evidence, not just a quality metric.
SWE.5 Software Component Verification and Integration Verification
What it is for: two things. Verifying that each software component behaves as the architecture says, and integrating the software elements step by step while verifying that they work together as the architecture and detailed design say.
What an assessor looks for: integration verification measures (data flow, interaction and timing between components, correct interpretation of shared data, resource consumption); separate measures for component behaviour; a defined integration sequence and preconditions; selection for the release scope; integration up to the complete software; recorded results; traceability; and a summary.
In practice: the PAM explicitly allows big-bang integration, continuous integration or stepwise integration, as long as the preconditions are defined. A CI pipeline that builds, integrates and runs component and integration checks on every merge can be the backbone of SWE.5. Software-in-the-loop simulation is named as a valid environment, and off-the-shelf components, open-source software and generated code all need to be qualified before they enter the integration.
SWE.6 Software Verification
What it is for: showing that the integrated software meets the software requirements.
What an assessor looks for: verification measures derived from the software requirements, with techniques suited to each requirement; a documented selection for the release scope, including regression; results with pass/fail status; bidirectional traceability between measures and software requirements, and between results and measures; and a summary.
In practice: the PAM suggests boundary values and equivalence classes for range-type requirements, and negative tests such as fault injection alongside the sunny-day cases. Its notes also make a useful point about reporting: the summary should give other parties enough information to judge the consequences. A list of 2,000 green test cases does not do that; a short statement of what passed, what failed, what was not run and why does.
Traceability and consistency: the thread through everything
If you read the six processes side by side, one base practice appears in every one of them: ensure consistency and establish bidirectional traceability. It is the thread that holds the V together.

The two words mean different things, and the PAM is careful to separate them. Traceability is the link: this software requirement comes from that system requirement, and is verified by those three test cases. Consistency is the content: the requirement actually says what the system requirement needs, and the test cases actually check it. A note repeated in almost every SWE process puts it plainly: traceability alone, the mere existence of links, does not mean the information is consistent. Assessors check both, usually by following a sample of links and reading what is on each end.
Why bother? The PAM gives two reasons that every engineer has felt: impact analysis (a customer changes one requirement, and you can find every design element, unit and test it touches) and coverage (you can show that every requirement is verified, and every test has a reason to exist).
Three practical points:
- Redundant links are not wanted. The model asks for a sensible set of trace paths, not every possible link. SWE.3, for example, can trace units to requirements directly or through the architecture.
- Not every requirement traces down. Process requirements or later lifecycle needs may have no design element. They still need to be verified.
- Put links where the work happens. Requirement IDs in code comments, test case attributes in the test tool and review checklists that include “is the content consistent?” are cheaper than a trace matrix maintained by hand before each assessment.
Capability levels: how “good” is measured
Back to the second dimension. Each process is rated on six capability levels. Every level adds one or two process attributes, and each attribute describes one aspect of capability.

In engineering terms, the first three levels mean roughly this:
- Level 1, performed: the outcomes are achieved. Requirements exist and are analysed, the code is verified, traces exist. How you got there does not matter yet.
- Level 2, managed: the work is planned, monitored and adjusted (PA 2.1), and the work products are defined, reviewed, put under control and kept up to date (PA 2.2). This is the level where “we did it, somehow, before the deadline” stops being enough.
- Level 3, established: the project follows a defined, organisation-wide standard process, tailored for the project, and that process is actually deployed with the right roles, skills and infrastructure.
Each attribute is rated on a four-point scale, taken from ISO/IEC 33020: Not, Partially, Largely or Fully achieved, each with a defined percentage band. To reach a level, its own attributes must be at least largely achieved, and every attribute below it must be fully achieved.

That rule explains a situation many teams meet for the first time in an assessment report: a process can have perfect plans and reviews and still stay at level 1, because one weakness in the level 1 outcomes, say missing traceability from tests to requirements, keeps PA 1.1 at L instead of F. Level 2 is built on a fully performed level 1, so the basics of SWE.1 to SWE.6 matter more than any amount of process documentation on top.
What it means for your daily work
Stripped of the vocabulary, SWE.1 to SWE.6 ask for things most good embedded teams already value. The difference is that the evidence has to exist, be consistent, and be findable by someone who was not in the room. For a typical change, that means:
- The change starts from a software requirement with an ID, a status and a link to the system requirement or architecture element it comes from.
- The architecture or detailed design is updated when the change affects them, including interfaces, value ranges, timing and resources, with a short rationale for any real decision.
- The code follows the agreed coding principles and can be traced to the detailed design.
- Each level has its verification measures, selected for the release you are building, with results recorded and linked: static analysis and unit tests for units, integration and component checks for the architecture, requirement-based tests for the requirements.
- Summaries tell the next person what passed, what failed and what was not done.
None of this requires a waterfall. The PAM explicitly allows continuous integration, iterative development and any integration strategy, as long as the consistency holds. In my experience, the teams that struggle in assessments are rarely the ones without documents. They are the ones whose documents, code and tests tell three slightly different stories.
If you learned Automotive SPICE 3.1. The SWE process names changed in version 4.0, and old training material is still everywhere:
| Process | Automotive SPICE 3.1 | Automotive SPICE 4.0 and 4.1 |
|---|---|---|
| SWE.1 | Software Requirements Analysis | Software Requirements Analysis |
| SWE.2 | Software Architectural Design | Software Architectural Design |
| SWE.3 | Software Detailed Design and Unit Construction | Software Detailed Design and Unit Construction |
| SWE.4 | Software Unit Verification | Software Unit Verification |
| SWE.5 | Software Integration and Integration Test | Software Component Verification and Integration Verification |
| SWE.6 | Software Qualification Test | Software Verification |
Beyond the names, version 4.0 replaced test case language with the broader verification measure, folded the separate traceability practices into a single “ensure consistency and establish bidirectional traceability” practice per process, and added the machine learning, hardware and validation groups around SWE. Version 4.1 changed nothing structural for software.
What I take away
It describes results, not rituals. Automotive SPICE is the what. Templates, tools and sprint rhythms are your how, and you are free to choose them. When a process feels bureaucratic, the first question is whether the bureaucracy comes from the model or from someone’s interpretation of it.
Consistency is the real test. Every SWE process ends with the same practice. Links are easy to create; requirements, design, code and tests that genuinely agree with each other are not. That is also what makes a codebase maintainable after the original team has moved on.
Level 1 carries everything. A higher capability level cannot compensate for weak basics, because every level needs the ones below it fully achieved. Good requirements, real design rationale and honest verification summaries are worth more than another process handbook.
Verification is broader than testing. Reviews, static analysis, simulations and tests are all verification measures. Choosing the right one for each requirement, and selecting what to rerun for each release, is engineering judgement the model expects you to document.
The next part will cover the system engineering group, SYS.1 to SYS.5: the processes that produce the inputs SWE.1 depends on, and that integrate and verify what the software team delivers.
Sources
- VDA QMC Working Group 13: Automotive SPICE® Process Reference Model / Process Assessment Model, version 4.1 (24 August 2026). All process names, purposes, outcomes, base practices, information items, levels, attributes and rating rules in this post come from this document.
- VDA QMC: Automotive SPICE® publications, including Automotive SPICE for Cybersecurity 2.0 (March 2025)
- VDA QMC: Automotive SPICE® PAM version 4.0 (2023)
- VDA QMC WG13 at the intacs regional event: ASPICE 4.1 and VDA ASPICE Guidelines 3rd edition (May 2026)
- UL Solutions: Understanding Automotive SPICE, on the VDA scope and plug-in concept
- Featured image: Bermix Studio, Unsplash (free to use under the Unsplash License)
- Figures: my own drawings, based on the PAM 4.1