What Are the Steps in the SoC Design Flow?
An SoC is designed in a fixed order of stages: define what it must do and its architecture, decide what runs in hardware and what in software, write or buy the RTL and integrate the IP blocks, verify it, synthesize and implement it, sign it off, and finally bring it up with real software. On an FPGA the last steps end in a bitstream you can load in minutes; for an ASIC they end in a tape-out to a foundry, months before you see silicon, which is why verification takes most of the effort.
What you'll learn
- Each stage of the flow and what it produces
- How hardware and software are split
- Why verification dominates the schedule
- How the FPGA and ASIC flows differ at the end
The stages
| Stage | Produces | Main risk |
|---|---|---|
| Specification and architecture | Features, block diagram, memory map, performance targets | Building the wrong thing |
| Partitioning | Which functions are hardware, which software | A bottleneck stuck in software |
| RTL and IP integration | Synthesizable RTL, configured IP, interconnect | Interface mismatches |
| Verification | Testbenches, coverage, regressions | Escaped bugs |
| Synthesis and implementation | Netlist, placement, routing, timing reports | Timing not met |
| Sign-off | Timing, power and physical checks passed | Late surprises |
| Bring-up | Boot code, drivers, a working system | Hardware and software disagree |
Partitioning hardware and software
Anything that changes often or is complex but slow belongs in software; anything that must be fast, parallel or very low power belongs in hardware. A common route is to profile the software first, then move only the hottest loop into an accelerator behind an AXI interface, as the custom peripheral project in this series does with a multiplier.
Why verification dominates
A bug found in simulation costs minutes; on an FPGA, a rebuild; in an ASIC after tape-out, a new set of masks and months. So most SoC teams have more verification engineers than designers, and use every technique in the verification course on this site: constrained random tests, coverage, assertions, UVM and formal proofs.
FPGA and ASIC endings
On an FPGA, implementation maps the design onto existing LUTs, flip-flops and block RAMs, and the result is a bitstream: if a bug appears, you fix it and rebuild. For an ASIC, implementation creates the transistors and wiring themselves, sign-off includes physical verification (DRC and LVS), and the output goes to a foundry. Many ASIC teams prototype on FPGAs first for exactly this reason.
Common mistakes
- Writing RTL before the memory map and interfaces are agreed.
- Leaving software out until the hardware is done; drivers find interface problems early.
- Treating timing closure as a last step instead of watching it from the first synthesis.
- Skipping a written verification plan.
Check your understanding
- Q1. Which stage turns RTL into a gate-level netlist? Answer: synthesis.
- Q2. Why do ASIC teams prototype on FPGAs? Answer: to run real software on the design before tape-out, when fixes are still cheap.
- Q3. What decides whether a function goes in hardware? Answer: whether it must be faster, more parallel or lower power than software can manage, weighed against how often it will change.
The SoC series
Last verified
Written on 17 November 2026; the FPGA flow steps match AMD's Vivado design flows guide.