How to Design a PCB: Step-by-Step EasyEDA Guide for Beginners

PCB design means turning a circuit you built with wires on a breadboard into a permanent printed circuit board, where copper traces connect the components. Today you don't need expensive software or a factory for this: with the free EasyEDA you draw the schematic in your browser, design the board, generate the manufacturing files and order with a few clicks; a week or two later you're holding professional-looking boards.

In this guide you'll follow the whole workflow step by step, using a small Arduino Nano based sensor board as the example: drawing the schematic, choosing the right footprint for each part, placing the parts, setting trace width for the current, adding a GND copper pour, hunting for errors with DRC, generating Gerber files, ordering and testing the board when it arrives. At the end we cover the design mistakes beginners make most often and briefly compare EasyEDA with its powerful alternative, KiCad.

What is a PCB and why move from a breadboard to a PCB?

A PCB is made of thin copper layers bonded to a glass-fibre reinforced epoxy (FR-4) sheet. Most hobby boards are two-layer: there's copper on the top and bottom, and the two layers are connected through small plated holes called vias. The green (or other coloured) coating over the copper is the solder mask; it protects the traces and makes solder stick only to the pads. The white lettering on top is the silkscreen layer. A breadboard is ideal for trying things out, but wires work loose with vibration, long jumpers pick up noise and the circuit won't fit in a box. A PCB gives a sturdy, compact, repeatable result that's easy to debug.

Example project: an Arduino Nano based sensor board

Throughout the guide we'll move a circuit people often build on a breadboard onto a PCB: an Arduino Nano, a DHT22 temperature and humidity sensor, a four-pin header for an I2C OLED display, two buttons, an LED and a passive buzzer. Instead of soldering the Nano directly to the board, we'll plug it into two 15-pin female headers, so you can take it out for another project or replace it easily if it fails. The board will take a 7–12 V adapter through a screw terminal and be protected against reverse polarity with a diode. For pin numbers, see Arduino Nano pinout.

PCB design workflow: 7 steps

1. Schematic: Draw the circuit with symbols and check every connection.
2. Footprints: Choose the pad and hole layout each symbol will occupy on the board.
3. Placement: Set the board size and place the parts in logical groups.
4. Traces: Draw the connections as copper traces; keep power traces wide.
5. Copper pour: Fill the empty areas with copper connected to GND.
6. DRC: Check the design rules and fix the errors.
7. Gerber and ordering: Generate the manufacturing files, check them and upload them to a manufacturer.

1. Drawing the schematic in EasyEDA

EasyEDA comes in two editions: the older, simpler Standard and the newer, more powerful Pro. Both are free and run in the browser or as a downloadable desktop client. If you're starting out, start with Pro. After creating a free account, make a new project; when it opens you get an empty schematic sheet. Search the Library panel for the part name or its LCSC part number and place it on the schematic; basic parts such as resistors, capacitors and LEDs come with a ready-made symbol and footprint. Then connect the pins with the Wire tool and use the VCC and GND symbols for power. If you're not used to reading schematics, How to read a circuit diagram explains the symbols one by one.

2. Choosing footprints: the symbol's counterpart on the board

The symbol shows what a part does in the schematic; the footprint defines the pads and holes its legs sit in on the board and the area it takes up. The same 10 kΩ resistor has dozens of footprints: a through-hole (THT) axial resistor with 7.62 mm or 10.16 mm pitch, or surface-mount (SMD) packages such as 0805 and 0603. Never pick a footprint without checking the dimensions of the part in your hand with a ruler or calipers. For your first board, it's best to start with THT parts that are easy to solder by hand; when you move to SMD, the 0805 size is the most comfortable to solder by hand. For the codes printed on SMD resistors, use the SMD Code Decoder tool.

3. Board size and placement

• Outline first: Draw the board outline. Our example board is 60 × 50 mm; many manufacturers make boards under 100 × 100 mm in their cheapest price bracket.
• Mounting holes: Put 3.2 mm (M3) holes in the four corners, about 3.5 mm in from the edge; screwing the board into a box becomes much easier later.
• Connectors at the edge: Make the screw terminal, the OLED header and the Nano's USB socket face the board edge, so parts don't get in the way when plugging in cables.
• Group your placement: Keep the power parts (terminal, diode, capacitor) in one corner and the buttons on the edge where the user will press them.
• Keep the sensor away from heat: Place the DHT22 away from the Nano's regulator and the buzzer; the regulator's heat can throw the temperature reading off by a few degrees.
• Leave room for soldering: Leave enough space between parts for the soldering iron tip; don't let the gap between two neighbouring pads drop below 1 mm.
• Silkscreen: Write each part's reference (R1, D1), the LED and capacitor polarities, the pin names and the board's name; don't let text run over the pads.

4. Routing traces and choosing trace width

When placement is finished you'll see thin lines between the parts; these ratsnest lines show connections that exist in the schematic but haven't been made in copper yet. You turn each one into a copper trace with the Track tool. A trace's width sets how much current it can carry: a narrow trace heats up at high current, causes voltage drop and in the worst case burns out. 0.25–0.3 mm is enough for signal traces; keep power traces such as 5 V and VIN at least 0.6–1 mm wide, especially if they'll feed servos, motors or LED strips. The values below are rough figures calculated with the IPC-2221 approximation for an outer layer with 1 oz (35 µm) copper and about 10 °C of temperature rise; leaving a safety margin is always a good idea.

Keep the gap between traces (clearance) at least 0.2–0.3 mm; most manufacturers can make tighter gaps, but a wide gap leaves room for error in both manufacturing and soldering. When a trace has to move to the other layer, use a via; a via with a 0.3 mm hole and 0.6 mm outer diameter is a standard choice for hobby boards. Turn corners with 45-degree bends and avoid sharp angles (less than 90 degrees). On two-layer boards, running traces mostly horizontally on the top layer and vertically on the bottom makes crossings easier to solve. To work out the LED resistor value, use the LED Resistor Calculator tool.

5. GND copper pour

Once all the traces are drawn, fill the remaining empty surface of the board with copper connected to the GND net; in EasyEDA the Copper Area tool does this. Add the copper pour to both the top and bottom layers and tie the two layers together with a few GND vias scattered across the board. This has three benefits: every part's GND connection is made the short way without drawing separate traces, the resistance and noise of the ground path drop, and less copper has to be etched away by the manufacturer. The GND pads of through-hole parts connect to the pour with thermal reliefs (four thin spokes), so the soldering iron can heat the pad without losing its heat into the large copper area. After adding the pour, rebuild it and remove any small copper islands that aren't connected to anything.

6. Running the DRC

DRC (Design Rule Check) is the tool that automatically scans your design against the rules you set: it lists traces that are too close together, copper too near the edge, overlapping pads, parts sticking out of the board and nets that still aren't connected. Click any line in the error list and EasyEDA shows you the problem spot. Run the DRC until no errors remain, but don't rely on it alone; DRC can't know that a footprint was chosen wrongly or that a pin was connected to the wrong net. Also do these checks by hand before ordering:

1. Make sure no ratsnest lines remain on screen and the DRC reports zero errors.
2. Print the board on paper at 100% scale and lay the real parts on the paper; the hole spacings and the Nano headers should match exactly.
3. Open the 3D view: check that parts don't overlap and that the USB socket and terminal face the edge.
4. Follow the power path: are the terminal, diode, capacitor and the Nano's VIN pin in the right order?
5. Check that the silkscreen has polarity marks, pin names, the board name and a version number (e.g. v1.0).

7. Generating Gerber files and ordering

Manufacturers don't work with your design file but with industry-standard Gerber files. Gerber describes each layer of the board in a separate file; hole positions and diameters go in a separate drill file. When you choose the Gerber output in EasyEDA's fabrication menu, all the files are put into a single ZIP archive; the option to order directly from EasyEDA's sister manufacturer is on this screen too. You can also upload the ZIP to any other manufacturer. Whichever you choose, after uploading, inspect your board layer by layer in the online Gerber viewer; this is your last chance to see that what you drew is what will be made.

Boards are usually made within a few days, while shipping can take a week or two depending on the method you choose. When the boards arrive, don't solder everything at once: first fit only the diode, capacitor and terminal, measure with a multimeter that there's no short between VIN and GND, then power it up and confirm you see the right voltage on the Nano's header. Then solder the parts from lowest to tallest: resistors, diode, buttons, headers and finally the big parts. For clean joints see How to solder, and for measuring see How to use a multimeter. Plug in the Nano and upload the test sketch below to check every connection on the board one by one.

1// Nano kartı ilk test: her bağlantıyı tek tek doğrula
2// Nano board first test: check every connection one by one
3#include <Wire.h>
4
5const int DHT_PIN  = 2;              // DHT22 veri hattı, 10 kΩ pull-up / DHT22 data line, 10 kΩ pull-up
6const int BUTON1   = 3;              // buton GND'ye / button to GND
7const int BUTON2   = 4;
8const int LED_PIN  = 6;              // LED + 330 Ω
9const int BUZZER   = 8;              // pasif buzzer / passive buzzer
10
11void i2cTara() {
12  byte bulunan = 0;
13  for (byte adres = 1; adres < 127; adres++) {
14    Wire.beginTransmission(adres);
15    if (Wire.endTransmission() == 0) {             // cihaz cevap verdi / a device answered
16      Serial.print(F("I2C cihaz / device: 0x"));
17      Serial.println(adres, HEX);                  // OLED genelde 0x3C / OLED is usually 0x3C
18      bulunan++;
19    }
20  }
21  if (bulunan == 0) Serial.println(F("I2C cihaz yok: A4/A5 yollarini kontrol et / no I2C device: check the A4/A5 tracks"));
22}
23
24void setup() {
25  Serial.begin(9600);
26  pinMode(BUTON1, INPUT_PULLUP);
27  pinMode(BUTON2, INPUT_PULLUP);
28  pinMode(LED_PIN, OUTPUT);
29  pinMode(DHT_PIN, INPUT);
30  Wire.begin();
31
32  Serial.println(F("--- Kart testi / board test ---"));
33  i2cTara();
34  // Pull-up direnci lehimliyse veri hattı boşta HIGH okunur
35  // If the pull-up resistor is soldered, the idle data line reads HIGH
36  Serial.print(F("DHT hatti / DHT line: "));
37  Serial.println(digitalRead(DHT_PIN) ? F("HIGH (pull-up tamam / OK)") : F("LOW (pull-up ya da kisa devre? / pull-up or short?)"));
38  tone(BUZZER, 2000, 150);                         // buzzer kısa bip / short beep
39}
40
41void loop() {
42  digitalWrite(LED_PIN, (millis() / 500) % 2);     // LED yarım saniyede bir / LED every half second
43
44  static bool once1 = HIGH, once2 = HIGH;
45  bool b1 = digitalRead(BUTON1);
46  bool b2 = digitalRead(BUTON2);
47  if (b1 == LOW && once1 == HIGH) { Serial.println(F("Buton 1 / button 1")); tone(BUZZER, 1000, 80); }
48  if (b2 == LOW && once2 == HIGH) { Serial.println(F("Buton 2 / button 2")); tone(BUZZER, 1500, 80); }
49  once1 = b1;
50  once2 = b2;
51  delay(20);                                       // basit debounce / simple debounce
52}

At startup the code scans the I2C bus and, if the OLED is plugged in, prints its address (usually 0x3C); if nothing is found, it tells you to check the A4 and A5 traces. If the R1 pull-up resistor is soldered correctly, the DHT22 data line reads HIGH when idle; if you see LOW, the resistor is missing or the line is shorted to GND. The buzzer gives a short beep at startup, the LED blinks every half second and each button prints its name to the Serial Monitor and makes a different sound. Once all these tests pass, you can add the sensor and display libraries and move on to your actual project.

Common PCB design mistakes

A quick look at KiCad: EasyEDA or KiCad?

In KiCad the workflow is the same: you draw the circuit in the Schematic Editor, assign a footprint to each symbol, do placement and routing in the PCB Editor, run the DRC and produce Gerber and drill files from the Plot menu. For your first board, EasyEDA's ready-made library and one-step ordering save time. As your designs grow, moving to KiCad makes sense if you want to work offline, keep your files entirely to yourself and use advanced features; the footprint, trace width, copper pour and DRC concepts you've learned here are the same in both programs.

The moment you hold your first PCB, you'll see a sturdy, repeatable board taking the place of the tangle of wires on your breadboard; even if you make a mistake, the second version is always better. Start with a small board with THT parts, double-check the footprints and power traces, and print it on paper to try the parts before ordering. The wiring diagrams of the LED, button, buzzer, DHT11, LCD and OLED projects in the BlueGrays app make a good starting point when designing your own board; get the circuit working on a breadboard with the app's steps first, then move it to a PCB.