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 SoC design flowSeven stages in order: specification and architecture, hardware and software partitioning, RTL design and IP integration, verification, synthesis and implementation, sign-off with a bitstream or tape-out, and bring-up with software.Specificationand architectureHardware and softwarepartitioningRTL design andIP integrationVerificationsimulation and formalSynthesis andimplementationSign-off, thenbitstream or tape-outBring-upwith software
In practice the arrows also run backward: verification failures and timing problems send work back to RTL or even the architecture.

The stages

StageProducesMain risk
Specification and architectureFeatures, block diagram, memory map, performance targetsBuilding the wrong thing
PartitioningWhich functions are hardware, which softwareA bottleneck stuck in software
RTL and IP integrationSynthesizable RTL, configured IP, interconnectInterface mismatches
VerificationTestbenches, coverage, regressionsEscaped bugs
Synthesis and implementationNetlist, placement, routing, timing reportsTiming not met
Sign-offTiming, power and physical checks passedLate surprises
Bring-upBoot code, drivers, a working systemHardware 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

Related

Sources

Last verified

Written on 17 November 2026; the FPGA flow steps match AMD's Vivado design flows guide.