PCB Design Basics: From Schematic to Manufactured Board

The first time you design a PCB, you spend the weekend learning a CAD tool and the next weekend convinced you have made a mistake somewhere. Two weeks after you click submit on JLCPCB, a small package arrives with five copies of your design, and the moment you plug one in and it works is genuinely magical. From that point on, "just etch a board" becomes a tool in your kit alongside soldering and writing firmware.

This article is the field guide to that first PCB. The workflow, the software, the gotchas, and the realistic cost of going from idea to physical board.

The four-step workflow

The fundamental PCB workflow. Each step has its own tools and gotchas; the order matters.

Step 1: schematic

The schematic is a logical drawing of your circuit. Components appear as standardised symbols (a resistor as a rectangle or zigzag, a capacitor as two parallel lines), connected by wires that show electrical relationships. The schematic does not care about physical placement — it only describes what is connected to what.

The work in this stage:

• Pull symbols from libraries (or draw your own for unusual parts).
• Wire them together according to your design.
• Annotate every component with a reference designator (R1, C1, U1) and value (10k, 100nF, ATmega328P).
• Run the electrical rules check (ERC) to catch unconnected pins, shorts to power, and obvious mistakes.

A clean schematic is readable. Group related circuitry, label nets meaningfully (USB_DP not NET12), use power and ground symbols rather than running long wires across the page. Future-you debugging this board in six months will thank present-you.

Step 2: footprints

Each schematic symbol must be assigned a footprint — the physical pattern of pads on the board where the component will solder. A 10k resistor's symbol is the same regardless of whether the physical resistor is 0805 surface-mount or a through-hole DIP. The footprint specifies which.

This is the step where most beginners get burned. A wrong footprint means the part will not fit on the board. Buy the actual component first; check the datasheet for its dimensions; pick the matching footprint from your library. KiCad's library has thousands of footprints covering most standard parts; for unusual parts, you may need to draw your own from the datasheet's dimensional drawing.

Step 3: PCB layout

Now you decide where on the physical board each component lives and how the copper traces connect them. This is the artistic step.

The basic rules:

• Place strategically. Connectors at edges. The microcontroller central. Decoupling capacitors as close to power pins as possible. Crystals adjacent to the chip's crystal pins.
• Route carefully. Power traces wider than signals. Signal traces 0.2–0.3 mm for hobby work. Avoid 90-degree angles (use 45 or curves). Keep high-speed signals (USB, crystal oscillators) short.
• Ground plane. The bottom layer should mostly be solid copper connected to ground. This is the single best practice for noise immunity. Vias between top-layer ground regions and the bottom plane glue everything together.
• Decoupling capacitors. Every IC's power pin gets a 100 nF capacitor between VCC and GND, placed within 5 mm of the pin. Skipping this is the most common cause of mysterious bugs.
• Test points. Add small via-sized test points on critical signals (3.3V rail, ground, MCU SWD pins). They cost nothing and save hours when debugging.

Step 4: generating Gerbers

Manufacturing files for PCBs are called Gerber files (one per layer) plus a drill file for holes. Most modern fabs (JLCPCB in particular) accept KiCad project files directly as a ZIP, but Gerbers are the universal format if you work with multiple fabs.

The export typically generates:

• Top copper, bottom copper
• Top silkscreen, bottom silkscreen (the white lettering)
• Top solder mask, bottom solder mask (the openings in the green coating)
• Top paste, bottom paste (only for SMT assembly)
• Edge cuts (the board outline)
• Drill file

Always preview the Gerbers before sending. KiCad's Gerber viewer (or the free online tool gerblook.org) shows what the fab will see. Catches mistakes the schematic and PCB editors can hide.

Software: KiCad and the alternatives

• KiCad (free, open-source) — the consensus pick in 2026. Mature, capable of professional work, no licensing cost. Five-board run from JLCPCB at $5. Recommended starting point.
• EasyEDA (free, web-based, owned by JLCPCB) — integrated with the JLCPCB component library, simpler interface. Lock-in to a single fab; harder to migrate later. Good for beginners; limited for serious work.
• Altium Designer ($350+/month) — industry standard for professional hardware teams. Powerful, polished, expensive.
• Eagle (Autodesk; subscription) — legacy hobbyist favorite, now under Fusion 360. Less popular than it was; Autodesk has been steering users to Fusion's electronics.
• DipTrace — capable mid-range, niche following.

Honest take: install KiCad, ignore the others until you have a specific reason. Tutorials, Stack Overflow answers, and library support are most abundant for KiCad.

Manufacturing: who to use and what it costs

For 5-10 boards of a 100×100 mm two-layer design:

• JLCPCB — $5 + shipping. 7–10 days from order to delivery. Quality is excellent for the price. Default choice for hobbyists worldwide.
• OSH Park — $5 per square inch (about $10–30 for typical hobby boards). US-based, slower (3 weeks), beautiful purple solder mask. Worth the wait if you need US manufacturing.
• PCBWay — similar to JLCPCB, slightly more expensive, often higher quality on advanced specs (4-layer, controlled impedance).
• Aisler — EU-based, fast turnaround, more expensive than JLCPCB.

For a first board, JLCPCB. Order an extra few boards as spares; the marginal cost is nothing.

Common beginner mistakes

• No decoupling capacitors. Most subtle problems traced to this. Add 100 nF per VCC pin, no exceptions.
• Footprint mismatch. The board arrives, the parts do not fit. Always verify against the actual physical part you plan to buy.
• USB-C connector wired wrong. USB-C has subtle requirements (CC pulldown resistors for device mode, 5.1 kOhm to ground on each CC pin). Many tutorials get this wrong; check the spec.
• Forgotten ground connection. A floating ground reads as no signal. Verify the ground plane is connected to your microcontroller's GND pin.
• Mirrored footprint. Surface-mount footprints can be applied to the wrong side of the board, putting pads on the back when you wanted them on the front. Always check the 3D preview.
• No test points. When debugging the board fails, you find yourself trying to probe a 0.4 mm pitch chip pin with a multimeter. Add a few 1 mm test points up front; cost nothing, save your sanity.

Frequently Asked Questions

How long until I get a board good enough to ship?

For a hobby project, the first board often works. For something you sell to customers, plan on three revisions: prototype to learn, refinement to fix the obvious mistakes, production to add manufacturing improvements. Each revision is two weeks calendar time.

Do I need to learn KiCad before designing my first board?

Yes, but the curve is shorter than it looks. Two evenings of following the official KiCad tutorial gets you to "I can do this on my own". The hard part is learning what makes a good schematic, not the mechanics of the tool.

Should I buy a soldering iron or pay JLCPCB to assemble?

Both. JLCPCB's PCBA service assembles SMT components for cheap (often $20–50 for a small board), saving you tedious manual soldering of 0805 parts. You will still want an iron for through-hole connectors, headers, and rework. The Pinecil at $25 is the right starting iron.

What about flexible PCBs or 4-layer boards?

Flexible PCBs (FPC) are useful for wearables and tight enclosures. JLCPCB makes them at modest premium. Four-layer boards are necessary when you have high-speed signals (USB at 480 Mbps and above), dense BGA chips, or strict noise requirements. For most hobby projects, two-layer is plenty.

How do I learn what a good board looks like?

Look at boards designed by people who clearly know what they are doing. The Adafruit Feather schematics are public. Open-source hardware projects on GitHub (Open EEG, Pine64 boards, FOSS keyboards) include their KiCad projects. Reading other people's schematics teaches more than any textbook.