1. LandOffer
  2. Blog
  3. All articles
  4. FPGA vs. Embedded Software Jobs: Check RTL, Timing, and Board-Bring-Up Requirements

Job search

FPGA vs. Embedded Software Jobs: Check RTL, Timing, and Board-Bring-Up Requirements

Three employer examples separate programmable-logic lifecycle work from processor software; a fictional C engineer maps supported claims and missing FPGA evidence.

9 min readLandOffer team

An embedded engineer may write C code that controls an FPGA without designing the logic inside it. An FPGA engineer may write Python and C++ around a hardware design without primarily owning the processor software. The shared board does not make those responsibilities interchangeable.

For FPGA versus embedded software jobs, compare the implementation artifact, the verification evidence, and the part of board bring-up you would own. We reviewed current primary employer material and AMD technical documentation on October 20, 2026. The examples below are a bounded role comparison, not a claim about every employer. For additional openings, browse recent roles on LandOffer.ai and inspect the actual responsibilities.

Two engineers compare a programmable logic design with processor software beside a shared development board.

Find the artifact the employer expects you to deliver

An FPGA-focused role can center on register-transfer-level design, or RTL, together with simulation, synthesis, implementation, constraints, and hardware validation. An embedded software role can center on code executed by a processor: startup, drivers, operating-system integration, device control, or applications. A system-on-chip can put programmable logic and processors in the same device, creating a close interface between the two jobs.

Identify the artifact you would change and the evidence needed to accept it. Are you modifying synthesizable logic and its clocked interfaces? Are you writing processor code that accesses registers exposed by that logic? Are you integrating vendor IP, maintaining a driver, or diagnosing the combined system? Those questions reveal more than the words firmware or software alone.

Both roles cross the hardware/software boundary. Both roles involve code, automated tools, debugging, and collaboration with electrical engineers. Their central design assumptions and acceptance evidence can differ, so a familiar language or shared board is insufficient to establish a match. A passing processor unit test does not establish that a logic design meets timing; a successful bitstream build does not establish that the associated processor software handles every error correctly.

When a posting includes both sides, identify the dominant responsibility and the expected depth. Do not infer that one engineer must independently own every layer merely because all of them appear in the product description.

Completed requirement map: RTL ownership and software ownership

The following map compares three employer examples. Normal Computing and Kapta Space describe FPGA lifecycle work; Etched describes a broader embedded systems position with several possible specializations. This is a classification of the stated work, rather than a ranking of employers or a hiring prediction.

Employer and role Principal artifact or deliverable Hardware and verification boundary Completed classification
Normal Computing — Hardware Engineer, FPGA FPGA implementation of ASIC RTL, integrated IP, prototyping and test infrastructure Multi-clock designs, CDC, timing closure, lab debugging and platform bring-up FPGA lifecycle ownership with supporting Python/C++ tooling
Kapta Space — Senior FPGA Engineer Radar-related RTL and FPGA/SoC implementation Synthesis, place and route, timing analysis, prototype verification and schematics Senior FPGA implementation and validation, despite broader firmware wording
Etched — Embedded Software Engineer Accelerator software, platform firmware, or host kernel/driver work Production hardware interaction; depth in one area with contribution across others Embedded systems work whose exact processor/logic boundary needs team clarification

Normal Computing makes the FPGA lifecycle explicit. Its Hardware Engineer, FPGA description described adapting ASIC RTL to FPGA platforms, including multi-clock architectures, CDC bridges, and timing closure. Platform selection, IP integration, lab debugging, and software around the hardware were part of the scope.

Python or C++ tooling therefore does not turn this into a general software role. The central evidence is taking logic through implementation and validation. A candidate who automated builds but did not own RTL or timing should preserve that narrower contribution. The current rendered page listed New York and Mountain View, with hybrid work.

Kapta uses firmware language for RTL-based work. The Senior FPGA Engineer posting described radar implementation, resource tradeoffs, RTL integration onto FPGA/SoC platforms, and hardware verification. Verilog or VHDL experience, targeted-hardware bring-up, and schematic reading appeared in the requirements.

Clock-domain crossing and timing-closure experience appeared among its bonus qualifications, while timing analysis was already part of the stated implementation work. We kept that hierarchy instead of treating every mention as an identical required skill. The role was on-site in Redmond, Washington, and its senior experience expectations should not be replaced by a beginner project checklist.

Etched shows why the embedded label needs a second reading. Its Embedded Software Engineer description spanned accelerator software, platform firmware, and host-side kernel and drivers. It included microcontroller and FPGA firmware in the platform area, alongside C/C++ fundamentals and low-level hardware interaction.

The role described specializing in one area while contributing across others. We would ask which implementation boundary a particular opening emphasizes, rather than treating the FPGA mention as proof that every embedded applicant must already own a full RTL flow. The listed location was on-site in San Jose.

These examples do not establish relative salaries, title frequency, remote availability across the industry, or an applicant's eligibility. Location, experience, and any role-specific conditions need checking on the employer page before an application.

Timing closure and CDC require different evidence

A waveform that looks correct in a functional simulation is useful evidence about that simulation. It is not, by itself, evidence that the implemented design meets its timing requirements on a particular target. When an FPGA posting asks for timing closure, look for experience with constraints, implementation reports, identified violations, and the changes you made to resolve them.

Avoid reducing timing experience to a single frequency claim. A credible account identifies the target, tool version, relevant clocks, constraints, implementation stage, and unresolved issues. If you only observed a colleague's report, describe that participation rather than claiming closure ownership.

Clock-domain crossing is another distinct boundary. AMD's UG906 CDC documentation, version 2026.1, describes structural analysis for potentially unsafe crossings associated with metastability or data-coherency issues. It explicitly distinguishes that report from timing-slack information.

That means “timing passed” and “CDC reviewed” are not interchangeable statements. A candidate should explain which analysis was performed and what the report actually supports. This article does not supply a universal synchronizer design or a constraint recipe; crossing behavior and the appropriate implementation depend on the interface and design.

The AMD constraint guidance also shows that constraint precedence can matter. For example, its specific XPM discussion warns about higher-precedence clock-group constraints overriding constraints supplied by the CDC macros. Recognizing a tool command is not the same as knowing whether it is appropriate for the design you are presenting.

Board bring-up is shared work with different owners

A board can fail because of processor startup, reset or clock behavior, programmable logic, an interface mismatch, or another system issue. Both FPGA and embedded engineers may participate. Your evidence should identify the symptom, the signals or logs inspected, the change you made, and the boundary you did not own.

For example, writing C code to exercise a register interface can support processor-side integration experience. Designing the register block and its clock-domain behavior is a separate contribution. A shared debug session may involve both, but the resume should not silently transfer ownership from one side to the other.

The same caution applies to loading a bitstream. Successfully programming a vendor example can establish a narrow tool-and-board task. It does not automatically demonstrate original RTL design, timing closure, or a verified custom hardware interface. Label the vendor example, target board, and steps you completed; preserve original design and production delivery as separate claims.

Ask how the team divides logic implementation, processor drivers, board support, and test infrastructure. The answer helps you select the right project evidence and reveals whether the role expects a specialist or someone who already spans the interface.

A project reviewer separates processor code, an RTL notebook and missing implementation reports beside an unpowered board.

Completed candidate review: a shared board, incomplete FPGA evidence

Leo is a fictional embedded C engineer. His stipulated production experience includes configuring a peripheral, maintaining a processor-side driver, and diagnosing register-access failures with a hardware colleague. He can describe the register map and timeout behavior, but another team designed the FPGA logic.

His personal learning folder contains a small proposed RTL counter, a testbench outline, and notes copied from a vendor board tutorial. For this article, the code and testbench are unexecuted synthetic examples. We did not simulate, synthesize, place and route, program a device, or measure hardware behavior.

The shared board makes “FPGA development and timing closure” feel like a plausible summary to Leo, even though the artifacts do not support it. He completes this artifact review before choosing his application story:

Available artifact in the scenario Supported contribution Missing evidence Completed claim decision
Processor C driver and reviewed register-map integration Embedded software at the processor/logic boundary Authorship of the RTL register block Keep driver ownership; remove RTL authorship
Joint failure report identifying a register-access timeout Cross-team diagnosis and interface reasoning Independent root cause of clock-domain or logic implementation issues Describe his observations and collaboration only
Unexecuted counter and testbench outline A learning design and proposed checks Simulation output, synthesis and implemented-target evidence Label study material, not a verified FPGA design
No constraints or implementation reports No demonstrated timing-closure ownership Target-specific constraint review, timing results and resolved violations Remove timing-closure claim
No CDC analysis or documented crossing design No demonstrated CDC review Interface-specific crossing rationale and analysis Preserve CDC as an explicit gap

His completed routing decision favors processor-side embedded work today. The C driver and interface diagnosis are relevant evidence for that boundary. For Etched, he would inspect the specialization and compare the full requirements before deciding whether his production experience aligns. The broad title does not establish that his current work covers all three areas.

Normal Computing's FPGA lifecycle ownership is a substantial stretch against these artifacts. Kapta's senior RTL, implementation, and targeted-hardware responsibilities also exceed his demonstrated FPGA scope. This is an evidence comparison, not an instruction that he is prohibited from applying or a prediction about an employer's response.

He rewrites his project summary as: “Maintained the processor-side C driver for an FPGA-backed peripheral; worked with the logic team to investigate register-access timeouts.” The statement identifies the shared system without claiming the logic team's design or reports.

His next learning plan is to complete a small, documented FPGA flow with the chosen target and tools recorded, then explain each stage's evidence separately. He plans to preserve the testbench, simulation results, constraints, implementation reports, and any later hardware observations, clearly identifying the stages he actually completes. This remains an unperformed plan; completing it would not by itself establish production expertise or satisfy a senior posting.

Build a search around the responsibility you can substantiate

Search for FPGA, RTL, embedded software, firmware, and platform roles, but classify them by the work rather than assuming the terms form clean categories. A posting can combine low-level software and programmable logic while still needing a specialist in one area.

For each serious lead, record who owns the RTL, timing and CDC analysis, processor code, and board bring-up. Compare required skills with preferred ones. Then select one project whose artifacts demonstrate your contribution to the relevant boundary, including limitations and unresolved results.

If you are moving toward FPGA work, do not hide embedded experience; interface debugging, register reasoning, build automation, and hardware collaboration can be useful. Explain where that experience stops. If you are moving toward processor software, do not assume RTL proficiency establishes driver, operating-system, or production software maintenance experience.

Browse recent roles on LandOffer.ai, open the employer's current description, and compare the delivered artifact with your own evidence. The strongest distinction is what you designed, verified, and debugged, with each claim tied to the work you actually owned.

Sources and Further Reading