Industry update — Global semiconductor sales reached $403.3 billion in the second quarter of 2026, up 35.1% on Q1, with June alone at $134.5 billion, and the industry body expects the year to exceed $1.5 trillion (Semiconductor Industry Association, 6 August 2026). For anyone scoping a custom FPGA programme that is a scheduling fact, not a headline: in a demand cycle like this one, device availability and speed-grade lead times belong in the specification alongside the throughput numbers.
In short: custom FPGA development is eight phases — specification, architecture and device selection, RTL, integration, timing closure, verification, bring-up, delivery. Each retires one class of risk, and licensing proven protocol IP removes whole phases of that risk rather than shortening them.
Between “we need an FPGA in this system” and a bitstream you are willing to ship sits a programme most schedules never survive intact. The slips rarely come from RTL being hard to write. They come from a requirement nobody wrote down, a device chosen before anyone counted the transceivers, a data rate only ever measured as a burst, or a protocol layer that behaved perfectly in simulation and then met a real device. This guide walks custom FPGA development phase by phase — the output each phase owes you, and the risk it retires.
- The short answer
- The eight phases of custom FPGA development
- Specification capture
- Architecture and FPGA device selection
- RTL design and proven FPGA IP reuse
- Integration, closure, verification
- Bring-up and delivery
- What a good statement of work covers
- Where this development model stops applying
- Frequently asked questions
The short answer
A custom FPGA development runs from a written specification through architecture and device selection to RTL built around proven, licensed protocol IP wherever a standard already exists — then integration, timing closure, verification, bring-up on real hardware, and delivery of a validated bitstream with its source, constraints, benches and documentation. The reusable layers, storage and bus and network, are where a licensed core turns months of write-and-debug into a bounded integration task. The custom effort belongs on what is genuinely specific to your system.
The eight phases of custom FPGA development
Each phase owes a concrete, reviewable output, and that output is the evidence a specific risk has been retired. A phase that produces no artefact did not happen, and its risk is still live in the next one.
| Phase | Output | Risk retired |
|---|---|---|
| 1. Specification | Functional, interface, performance and environmental requirements, with acceptance criteria | Building the wrong thing, or one nobody can declare finished |
| 2. Architecture & device | Block diagram, clock and data-flow plan, build-vs-license decision per block, target device | A device that cannot carry the design: too few transceivers, wrong hard blocks, no headroom |
| 3. RTL design | Synthesisable VHDL/Verilog for custom blocks, plus configured licensed IP for standard protocols | Re-solving protocol problems and inheriting their debug tail |
| 4. Integration | Assembled top level: interconnect, memory map, clocking and reset architecture, constraints | Blocks that each work alone and deadlock together |
| 5. Timing closure | Design meeting timing across the required corners, with a utilisation report | A design that simulates correctly and fails intermittently in silicon |
| 6. Verification | Benches, protocol compliance and coverage evidence against the specification | Defects escaping to the bench, where they cost far more to find |
| 7. Bring-up | Working design on the target board with real peripherals, plus measurements | What simulation cannot model: real devices, signal integrity, thermal behaviour |
| 8. Delivery | Bitstream, source, constraints, benches, integration guide, release notes, support window | A working design nobody but its author can maintain |
Specification capture
This is the cheapest place to fix a mistake and the one most often compressed. Pin down the functional requirements in terms a test can be written against, every external interface with its standard and revision, the environmental and lifecycle envelope, any certification need — and performance stated as a sustained figure.
That last point causes most late-programme pain. A sustained rate is the throughput a design must hold indefinitely, at the worst-case payload and access pattern; a burst rate is the peak it can touch briefly, and only the first one sizes the design. Write down both and label which is which. On certification, the evidence trail is planned, not reconstructed: DO-254 documentation is listed as “available on request” across our catalogue, and that request belongs in phase one. The output is a document both sides sign, whose most valuable section is the acceptance criteria. A programme without them does not end, it runs out of budget.
Architecture and FPGA device selection
Architecture partitions the design into blocks and, for each, decides: build or license. That single decision carries the largest schedule leverage in the programme — we examine it in FPGA vs ASIC: when to use each, and why IP reuse matters. Device selection then follows the architecture rather than habit:
- Hard blocks — PCIe hard block, transceiver count and line rates, memory controllers. No clever RTL creates one that is not there.
- Headroom — a device that fits at 95% utilisation does not fit, because closure and every future change need room.
- Speed grade and package — they drive closure, cost, board design and, in a tight market, lead time.
- Family support — whether the IP you intend to license is already proven there. Our catalogue spans AMD from Spartan 6 and Artix 7 through Zynq 7000 and UltraScale+, Altera from Cyclone IV GX through Stratix IV GX and Agilex 7, plus Microchip PolarFire — because a core never closed on your family is a research project, not a component.
Weighing two candidate devices for a design that has to sustain a fixed rate to storage? A short technical conversation usually settles which one has the headroom.
RTL design and proven FPGA IP reuse
The part worth paying for is the logic that exists only because of your system: your processing pipeline, control law, sensor interface, data format. Everything around it — storage stack, bus interfaces, network MAC, avionics bus — is a solved problem with a published standard. The schedule cost of re-solving it is not the writing; a competent engineer can write a protocol state machine. It is the debug tail: the months spent discovering how the standard behaves against real devices and real error cases, months invisible in the original plan. A core already through that tail on your family arrives with it retired. The reusable layers in the systems we work on:
- Storage — NVMe Host IP handling PCIe root-port and NVMe configuration, with up to 8 name spaces, up to 16 independent I/O queues, sectors of 512 bytes or 4096 bytes and per-queue buffers from 32 KB to 1024 KB; SATA Host and Device IP covering SATA I, II and III at 1.5 Gbps, 3 Gbps and 6 Gbps respectively, with transport, link and PHY layers, NCQ and 48-bit sector addressing.
- File systems — exFAT and FAT32 File-System IP in C source, when the media must be readable on a PC rather than as raw blocks.
- Network and avionics — a 10 Gbit Ethernet MAC to IEEE 802.3ae with jumbo frames, pause frames and VLAN support; an ARINC 429 core on AXI-Lite running up to 2.5 Mbit/s with independent Rx and Tx.
- Serial macros — I2C, SPI and UART controllers, the small blocks that quietly cost a fortnight each from scratch.
Two properties decide whether reuse helps. Delivery in source — ours ship as VHDL or Verilog with C source drivers, so they can be read, constrained and modified rather than treated as an undebuggable black box. And the interface presented, typically AXI4-Lite or APB for control and AXI4 or Avalon for data, because a clean standard interface makes integration bounded. Our buyer’s checklist for choosing an FPGA IP vendor lists the questions to ask.
Integration, closure, verification
Integration
Integration is where blocks that each pass their own bench discover they disagree. The work is interconnect topology, a documented memory map, and above all the clocking and reset architecture. A clock-domain crossing treated as a wire rather than a designed component is the classic fault that passes simulation and fails intermittently on the bench.
Timing closure
Closure is not a phase you enter at the end; it is a constraint you write at the beginning. The constraints file is a design artefact of the same standing as the RTL, and an unconstrained path is not a passing path but an unchecked one. Closure then means meeting timing across the required corners with a utilisation report proving the headroom survived. AMD’s UltraFast Design Methodology Guide and Design Analysis and Closure Techniques are the reference for that flow.
Verification
Verification decides whether bring-up takes a week or a quarter, because every defect caught in simulation is one nobody hunts with a logic analyser. It combines directed benches written against the acceptance criteria, coverage-driven verification — standardised as UVM and published as IEEE 1800.2 — and protocol compliance checking. We treat it separately in FPGA verification services: validating storage and bus IP.
Bring-up and delivery
Bring-up is where the design meets what simulation could not model: real devices with their own firmware quirks, real signal integrity, real thermal behaviour. It is also the phase most often left as an unbudgeted remainder, which is why it eats the contingency.
What keeps it short is a strict order. Prove configuration and clocks. Prove the control plane — read a status register, then issue one transaction and check the response. Prove a single data transfer. Only then scale to sustained rate and measure it. Debugging a stall at full rate with three unproven layers underneath is the slowest way to find a one-line fault. Doing this first on a known-good platform — KC705, VC707, ZC706, KCU105, ZCU102 or ZCU106 with the appropriate FMC storage mezzanine — means that when your own board arrives, any new fault is the board’s.
Delivery is not a bitstream alone; that is a binary nobody can maintain. It is the bitstream plus RTL source, constraints, benches and results, integration documentation covering the memory map and interfaces, release notes naming the tool version and device the build was closed on, and a defined support window — a design closed on one tool release is not automatically closed on the next. For the wider picture, see FPGA design services: what an IP-focused design house delivers.
What a good statement of work covers
Most disputes on FPGA development contracts are not about engineering quality. They are about something the statement of work never mentioned. A sound one is explicit on:
- Scope and explicit exclusions — what is out is more useful in writing than what is in.
- Acceptance criteria as numbers — figures and test conditions, not adjectives.
- Deliverable format — source RTL, encrypted netlist or bitstream only; this decides whether you can maintain it yourself.
- IP ownership and licensing — who owns the custom RTL, and on what terms pre-existing cores are included.
- Target device and change control — changing the device is a change of scope, because it can invalidate closure.
- Hardware and lab access — who provides boards and peripherals, and by when.
- Verification evidence — which benches, coverage and compliance results are handed over.
- Bring-up support — how many engineer-days, and whether on site.
- Documentation set — named documents, not “documentation”.
- Maintenance window — how long defects are fixed for, and what happens on a new tool version.
- Certification data package — for airborne work, which DO-254 artefacts are supplied and in what form.
Where this development model stops applying
- Volume economics beat flexibility. At high volume with a frozen feature set an ASIC changes the arithmetic, and with it the phase model and the cost of a mistake. See FPGA vs ASIC.
- You only need the standard part. If an existing core covers the requirement, licensing it is far shorter than a development programme — a purchasing decision, not an engineering one.
- The requirement is still moving. If the specification cannot be frozen, no phase model holds; a short feasibility or architecture study, scoped separately, is the honest first step.
- You want exact durations or figures. Schedule length, LUT/FF/BRAM utilisation and achievable rates come from a real estimate against your specification and your own closure — never from a generic figure in an article.
In summary
Custom FPGA development is not one long act of writing RTL. It is eight phases, each owing an output that retires a named risk — and two of those phases decide the rest. Get the specification right, with performance as a sustained figure and acceptance criteria as numbers. Get the build-versus-license decision right, so custom effort goes only where the system is genuinely yours. After that, the programme is engineering. Without them, it is archaeology.
Frequently asked questions
How long does a custom FPGA development project take?
Any figure quoted before a specification exists is a guess. Duration is driven by how much is genuinely custom, how many interfaces must be brought up against real devices, and whether the device and board already exist. What can be said is where the time goes: specification and architecture are short but decisive, verification and bring-up absorb the overruns.
What is the difference between buying an IP core and having a design house build the whole thing?
An IP core is a component: a proven implementation of a standard protocol that you integrate and support yourself. A custom development is a programme delivering a complete, validated design for your device and board. They are layers, not alternatives — a well-run development licenses cores for the standard protocols and spends custom effort only on what is specific to your system.
Do we own the RTL at the end of the project?
That depends entirely on what the statement of work says, which is why it must say something. Typically custom RTL and pre-existing licensed cores are treated differently: the custom work is delivered under terms agreed for your programme, while a protocol core stays under its own licence. Settle both before work starts, along with the deliverable format, because that decides whether you can maintain the design without returning to the supplier.
Which FPGA family should we target?
Let the architecture decide, not habit. Count what the design physically needs: transceivers and their line rates, whether a PCIe hard block is required, memory bandwidth, and logic and memory with real headroom. Then check speed grade, package, power, device longevity and lead time, and confirm the IP you intend to license is proven on that family. A core closed on your exact family is a component; one that is not is a research task in disguise.
What do you need from us to start a custom FPGA development?
At minimum: the functional requirements, every external interface with its standard and revision, and the performance target as a sustained rate with worst-case conditions rather than a burst figure. Beyond that, the environmental and power envelope, any certification requirement, the target device if fixed, and what hardware exists. If several are still open, a short feasibility study beats starting against a moving specification.
Can a custom FPGA design be certified for avionics use?
Airborne electronic hardware is developed against RTCA DO-254, and certification is a property of the whole programme and its evidence trail rather than of the bitstream. It must be planned from phase one, because the artefacts cannot be reconstructed convincingly afterwards. DO-254 documentation is available on request for our cores; the applicable design assurance level and the certification route are set by your system safety assessment and your certification authority.
How we write these guides: each is drafted by the engineers who run these programmes and support our cores. We describe standard-defined design-flow practice and defer schedule durations, resource utilisation and achievable throughput to an estimate against your own specification — never to a made-up figure.
Have a specification, or the beginnings of one? Tell us the interfaces, the sustained rate and the target device — we will scope the development, or tell you which existing core already covers it.
- Semiconductor Industry Association — Global Semiconductor Sales Increase 35.1% from Q1 2026 to Q2 2026 (6 August 2026).
- Arm — AMBA specifications: the AXI interfaces IP cores present at integration.
- AMD — UltraFast Design Methodology Guide (UG949): clocking, constraints, clock-domain crossing.
- AMD — Design Analysis and Closure Techniques (UG906): timing analysis and closure.
- IEEE — Standard 1800.2 (UVM) and Accellera — UVM reference implementation: the verification methodology.
- PCI-SIG — PCI Express specifications and NVM Express — NVMe specifications: the storage stack beneath a host core.
- RTCA — standards catalogue: publisher of DO-254, design assurance guidance for airborne electronic hardware.
