A first PCB is two jobs, and most guides blur them. One is building the board: the schematic, the footprint for every part, where each part sits, the copper between them, a check against what a factory can make, and the files the factory needs. The other is making it: a board house that takes those files and makes the board. I work on PCBEditor, a PCB builder that runs in the browser, so take my view of the first half with that in mind. Here is a real board taken from one description to files a fab will accept, and the checks that decide whether your first board works.
Short answer: a PCB builder turns a circuit into a board a factory can make: parts and footprints, placement, routing, a check against the factory's limits, and the files it needs. A PCB maker is the factory that makes the board from those files. You need both, in that order. A quote page cannot fix a board with the wrong footprint, and a builder cannot make the board for you.
Builder or maker?
People search "PCB builder" and "PCB maker" for two different things, and it helps to know which one you need first.
A PCB builder (the design side). Software that turns a circuit into a board: the schematic, the footprint for every part, where each part sits, the copper between them, a check against what a factory can make, and the files the factory needs.
A PCB maker (the making side). A board house that takes those files and makes the board: JLCPCB, PCBWay, OSH Park and many others. Some also solder the parts on (assembly). They quote from your Gerber, drill and BOM files, and some offer an instant-quote page that is also called a "PCB builder".
The board: a USB-C LiPo charger
A real board, built on pcbeditor.com and checked by a person afterwards. This is the description, exactly as it was typed:
Single-cell LiPo charger board: USB-C 5 V input, MCP73831 charger set to 500 mA, a charge status LED, a JST-PH 2-pin battery connector, and an AP2112K 3.3 V regulator output on a 3-pin header. 2-layer board.

One description in, one board out: the USB-C LiPo charger as PCBEditor built it on 17 October 2026. Left, the routed board (14 parts, 32.5 × 34.5 mm, two layers, every net routed, 0 design-rule errors); top right, the schematic it came from; bottom right, the same board assembled in 3D.
- Describe what the board must do. Name the job, the parts you care about and the layer count. Parts you do not name are chosen for you, and the reason for each is shown, so you can swap any of them.
- Read the schematic. It came back with the MCP73831 charger and 2 kΩ on PROG, which sets 500 mA (the datasheet's current is 1000 V divided by the PROG resistance), the charge LED on STAT, 5.1 kΩ pull-downs on both USB-C CC pins so a USB-C charger supplies 5 V, and the AP2112K fed from the battery with its enable tied high.
- Get a placed, routed board. Footprints, placement and routing followed: 14 parts on 32.5 × 34.5 mm, two layers, USB-C on the top edge, the battery connector bottom left and the 3.3 V header bottom right. Every net routed, 0 design-rule errors.
- Look at it in 3D. Every part has a model, so you can see connector heights and whether the plug and the battery lead have room before anything is made.
- Check it with your own eyes. It was right on the first pass with no edits. One warning needed a person: it assumed 5 V on the regulator, but the regulator runs from the battery (4.2 V at most), so its worst case is about 0.54 W at the AP2112K's 600 mA, not 1 W.
- Export and order. The export held Gerber, drill, pick-and-place and BOM, ready to upload to the board house of your choice.

The generated schematic of the LiPo charger: USB-C input with 5.1 kΩ CC pull-downs, the MCP73831 with 2 kΩ on PROG (500 mA) and its charge LED on STAT, and the AP2112K 3.3 V regulator fed from the battery, out to a 3-pin header.
That is the whole loop for a simple board: a few minutes of building and a few minutes of reading. A board with a microcontroller takes longer to check, not longer to build, because there are more pins to compare with the datasheet.
You do not have to describe it. You can place parts and wire the schematic yourself, start a blank board in Blank Studio (pick a size or draw the outline, choose the layer count and your fab's design rules), or import a KiCad project or a set of Gerbers and keep working on them. Boards can have two to sixteen copper layers.
Passing the design-rule check is not the same as being right
A builder that only generates is a slot machine. Every board stays editable: move parts, redraw traces, change values in the schematic, or ask for a change in the chat and let only the affected nets be routed again.
On an ESP32-C3 sensor board, the first layout put the module in the middle of the board with its antenna over other parts and the ground pour. It passed the design-rule check, because the rules were met; it would still have made a weak radio. One chat edit moved the module to the top edge so the antenna overhangs the board. Another moved a button that came out on a GPIO to the module's enable pin, where a reset button belongs.

The first layout: the module in the middle, with its antenna end over R1, the regulator and a ground pour that covers the whole bottom layer. It passed DRC. The review caught it.

After review: 21 parts on 32.6 × 44.1 mm, two layers, every net routed, 0 DRC errors. The module sits on the top edge so its antenna overhangs the board.
The check measures copper against rules: clearances, widths, drills. It cannot know that an antenna needs clear space or that a button belongs on the reset pin. Look at the board as well as the check.
Check it before you order
When you start a blank board you choose the design rules for the board house you will order from, and every trace is routed and checked against them:
| Preset | Process | Min trace and clearance |
|---|---|---|
| JLC Standard | JLCPCB 2-layer standard | 0.127 mm |
| JLC 4-Layer | JLCPCB 4-layer standard | 0.1 mm |
| PCBWay Std | PCBWay standard | 0.15 mm |
| OSHPark | OSH Park 2-layer | 0.127 mm |
| Custom | Enter your own rules | yours |
Run DRC and each finding says what is wrong and by how much, and takes you to the spot. Review my design reads the design-rule and electrical findings back in plain words: what is wrong, why it matters, and what to do. The counts come from the checkers, so nothing is guessed.

The design-rule check on an Arduino Nano motor driver: 0 errors and 1 warning (a courtyard overlap), with the board's net classes, trace widths and clearances in the Fab panel on the right.
Then read the ratings yourself. That same motor driver asked for a 6 to 12 V motor supply, but the DRV8833 it used is rated for 10.8 V. The build did not flag it (October 2026); the datasheet does. Check every part's voltage and current against your supply before you order.
Get it made
The builder does not make boards; it hands you the files, and you choose who makes them. One export gives you everything a board house or an assembly house asks for:
- Gerber X2 for every copper, mask, silkscreen and outline layer, and an Excellon drill file
- Pick-and-place (CPL) and a BOM for assembly
- IPC-D-356 netlist, IPC-2581 and ODB++ for houses that prefer them
- Assembly and fabrication PDFs, a STEP model, and a KiCad board

One export dialog for every fab format, in one zip.
For JLCPCB there is a one-click package with the Gerbers, the BOM and the pick-and-place file. If a design-rule error is still on the board, the export holds back the files it affects and says why, so a broken board does not reach the factory by accident.
Before you upload, open the zip in a Gerber viewer: outline present, drills where you expect them, mask openings on every pad. Then compare quotes from more than one board house for your board size, layer count and quantity.
Choosing an online PCB builder
Whichever builder you use, ours or another, these are what decide whether the first board works:
- Real parts with real footprints. Pads drawn from a standards-based library where one exists, not invented, and a pin map that matches the datasheet. A wrong pin 1 is the most expensive mistake in a first board.
- A design-rule check set to your fab. Trace width, clearance, drill and annular ring checked against the process you will order, before you order it, with every finding located on the board.
- Files every fab accepts. Gerber, Excellon drill, pick-and-place and BOM at the least; IPC-2581 or ODB++ if an assembly house asks for them.
- A way out. Export to KiCad, so the board is yours to take to any tool later. A builder you cannot leave is a risk on a product.
- Honest failure. When routing cannot finish, the builder should name the nets left open and refuse to hand half a board to the fab, not report a percentage.
- Enough layers for what comes next. Two layers covers most first boards. When the next one needs four or six, it should not mean a new tool.
What it will not do
It will not design a circuit you cannot describe. If you do not know what the board should contain, start from a reference design or an example and change it. The builder makes the mechanical decisions well; the purpose of the board is yours. And dense boards are the hard case: a dense four-layer board around a fine-pitch microcontroller or a large BGA is where you are most likely to see nets left unrouted. The builder names them, and you move parts or route those by hand.
Try the same board
If you want to build this charger yourself, this link opens the editor with the description already typed in. Change anything you like before you build it. It is free to start and there is nothing to install. The full page, with every step and the FAQ, is at pcbeditor.com/pcb-builder.
What was your first PCB, and what went wrong on it? I'm collecting the mistakes that the design-rule check passed and the board still failed on: wrong pin 1, an antenna under copper, a part run past its rating.
Top comments (0)