How to Transition from Arduino to Custom PCB

Electronics engineer soldering components onto a custom PCB board with Arduino prototype nearby on workbench

Your Arduino prototype works. The sensor reads correctly, the motor spins on command, the LED blinks exactly when it should. And yet every time you move the breadboard, a jumper wire pops loose and the whole thing dies. You’ve rebuilt the same circuit three times. You’re holding a functional project hostage on a $3 breadboard with $2 worth of jumper wires, and it feels fragile because it is fragile.

Here’s the thing most makers don’t realize: you’re closer to a custom PCB than you think. That messy breadboard circuit? It already is your schematic. You’re not designing a board from scratch. You’re translating something that already works into a permanent form. The jump from Arduino to PCB is less about learning new electronics and more about learning a new file format.

This guide walks you through every step: documenting your circuit, understanding what the Arduino board does behind the scenes, drawing a schematic, laying out a PCB, ordering it, and powering it on. We’re focused on ATmega328P-based boards (Uno, Nano, Pro Mini). If you’re working with an ESP32 or RP2040, the general process applies, but the specific support circuitry differs enough that it deserves its own guide.

Let’s make your project real.

Document Your Working Circuit Before You Change Anything

Start with what works. Before you open any software, grab your phone and photograph your breadboard from directly above. Get every wire, every component, every connection visible.

Then trace every connection and write it down. You need a complete record of:

  • Every component: sensors, actuators, resistors, capacitors, LEDs, modules
  • Every Arduino pin used: note whether it’s digital I/O, analog input, PWM, I2C (SDA/SCL), or SPI (MOSI/MISO/SCK)
  • Power connections: what voltage each component needs, where power comes from
  • Any external modules: I2C breakout boards, motor drivers, relay modules. Open these up conceptually, because you may want to integrate their circuitry onto your custom board

Draw a schematic. It doesn’t have to be pretty. Pencil and paper works. What matters is that every connection between every pin and every component is recorded explicitly. If your project has an I2C temperature sensor on pins A4 and A5 with 4.7kΩ pull-ups, that needs to be on the page.

This hand-drawn schematic is your design. The rest of this process is just making it manufacturable.

The “Hidden” Circuitry Your Arduino Has Been Providing for Free

When you plug a sensor into an Arduino Uno, you’re not really connecting to a bare microcontroller. You’re connecting to a system that includes power regulation, a clock source, reset circuitry, and a USB programming interface. To build a custom board from your Arduino project, you need to replicate these support systems. The good news: it’s only about 10–15 components.

Power regulation. Your Arduino has an onboard 5V regulator (usually an AMS1117-5.0 or similar) that takes 7–12V input and provides a clean 5V rail. On your custom board, you need the same: a voltage regulator, an input capacitor (typically 10µF), and an output capacitor (10µF). Add 100nF ceramic decoupling capacitors near the MCU’s VCC pins.

Clock. The ATmega328P needs an external 16MHz crystal and two 22pF load capacitors. These three components replace the ceramic resonator or crystal on the Arduino board.

Reset. A 10kΩ pull-up resistor from the RESET pin to VCC keeps the chip running. Add a tactile button to ground for manual reset if you want it. A 100nF capacitor on the reset line enables auto-reset for serial programming.

USB-to-Serial. This is the one piece you can skip. The Arduino Uno uses a dedicated chip (ATmega16U2 or CH340) to convert USB to serial for programming. On your custom board, you can instead add a 6-pin FTDI header and use a $5 USB-to-serial adapter for programming. Or add a 6-pin ISP header and program directly. Either approach saves board space and component cost.

Bootloader. The ATmega328P on your Arduino came pre-loaded with the Arduino bootloader, which is what lets the Arduino IDE upload sketches over serial. Your blank ATmega328P chip won’t have this, so you’ll need to burn it (more on that in the assembly step).

The entire Arduino Uno schematic is open source. Download it from arduino.cc and keep it open as a reference. It’s the most useful cheat sheet you’ll have throughout this process.

Create Your Schematic in KiCad

KiCad is free, open source, and fully capable for this level of project. Download it from kicad.org. You don’t need to pay for anything.

Open the schematic editor and start placing components. Work in this order:

First, the MCU and its support circuit. Place the ATmega328P symbol. Add the 16MHz crystal and its two 22pF caps connected to the XTAL1 and XTAL2 pins. Add the voltage regulator with input and output caps. Add the 10kΩ reset pull-up. Add 100nF decoupling caps on every VCC pin. This standalone ATmega328P circuit is your board’s foundation.

Then, your project-specific circuitry. Add every sensor, LED, resistor, connector, and actuator from your hand-drawn schematic. Connect them to the correct ATmega328P pins. Note that Arduino pin numbers and ATmega328P pin numbers aren’t the same. Arduino pin D13 is ATmega328P pin PB5 (physical pin 19 on the DIP package). The Arduino pin mapping diagram is essential here.

Use net labels instead of running wires across the entire sheet. A net label called “SDA” on the MCU and another “SDA” on your sensor creates an implicit connection. This keeps your schematic readable.

Add power flags to tell KiCad where power enters your design. Without them, the Electrical Rule Check (ERC), KiCad’s built-in error-finder, will flag warnings.

Run the ERC when you’re done. Fix every error. Review warnings individually. A clean ERC doesn’t guarantee a working board, but errors here guarantee a broken one.

Assign Footprints: Choosing Between SMD and Through-Hole

Every symbol in your schematic represents an abstract component. You now assign each one a footprint, the physical pattern of pads or holes that will exist on your actual board.

For your first custom PCB, stick with through-hole components. They’re dramatically easier to solder by hand, easier to inspect, and easier to desolder when you inevitably need to fix something. Choose the ATmega328P in a DIP-28 package and put it in a socket. If you fry the chip or need to reprogram it externally, you just pull it out.

If you want to go smaller, large SMD packages work too. 0805-size resistors and capacitors (2mm × 1.25mm) are manageable with a standard soldering iron and a steady hand. Anything smaller than 0603, save for version 2.

The critical step: verify that the footprint you assign in KiCad matches a component you can actually buy. Check Mouser, DigiKey, or LCSC. A schematic full of components that are out of stock or don’t exist in your chosen package is a design that can’t become a board.

Lay Out the PCB

In KiCad, click “Update PCB from Schematic” and every component footprint appears in a jumbled pile next to a blank board outline. Your job is to arrange them.

Place the MCU near the center of the board. Everything radiates outward from it.

Place the crystal and its two capacitors as close to the MCU’s XTAL pins as physically possible. This isn’t optional. Long traces on a clock signal pick up noise and can prevent the chip from starting. Within 5mm is ideal.

Group related components. Power regulation goes near where external power enters the board. Sensor components go near their connector. Keep signal paths short and logical.

Place connectors at the board edges. Power input, programming header, sensor connectors: anything you’ll plug a cable into should be accessible.

Then route traces, the copper paths that replace your jumper wires:

  • Power and ground first. Use 0.5mm or wider traces for power. Use a ground pour (a copper fill connected to GND that covers unused board area) on one layer. This simplifies grounding and reduces electrical noise.
  • Signal traces next. 0.25mm width is fine for logic-level signals.
  • A two-layer board is standard and cheap. Route most signals on the top, use the bottom for ground pour and occasional crossings.

Run the Design Rule Check (DRC). This checks that traces aren’t too close together, pads aren’t overlapping, and your design is manufacturable. Fix every error. Then visually inspect the board. Does the layout make physical sense? Are connectors oriented correctly?

Generate Gerbers and Order Your Board

Gerber files are the universal language of PCB fabrication. They describe each layer of your board (copper, silkscreen, solder mask, drill locations, board outline) in a format every fab house understands.

KiCad has built-in export presets for popular manufacturers. For JLCPCB, use their recommended plot settings (available on their website). Export, and you’ll get a folder of files.

Upload the Gerber set to your fab house of choice. JLCPCB, PCBWay, and OSH Park are all well-suited for first-time orders. For a standard board, the defaults are perfect: 2-layer, 1.6mm thick, HASL (hot air solder leveling) finish, green solder mask.

Cost: 5 copies of a small board from JLCPCB typically runs $2–$8 plus $5–$15 shipping. Total delivered: often under $20. Turnaround is about one to two weeks.

Before you click “order,” use the fab house’s online Gerber viewer. Visually confirm that copper traces, drill holes, silkscreen labels, and board outline all look correct. Five minutes of checking saves two weeks of waiting for a board with a missing connection.

Assemble, Bootload, and Power On

Your boards arrive. Inspect them for obvious defects: missing traces, misaligned drill holes, solder mask problems. This is rare with modern fab houses, but check.

Order your components from Mouser, DigiKey, or LCSC based on your bill of materials (BOM). KiCad can export a BOM directly from your schematic.

Solder in this order:

  1. Low-profile components first: resistors, ceramic capacitors
  2. The IC socket (if using DIP ATmega328P; don’t insert the chip yet)
  3. Voltage regulator and electrolytic capacitors
  4. Connectors, headers, and tall components last

Before inserting the MCU or powering anything, grab a multimeter. Measure resistance between VCC and GND. If it’s near zero ohms, you have a short. Find it and fix it before applying power. Once resistance checks out, apply power and verify you get the correct voltage (5V or 3.3V) at the MCU’s VCC pads.

Insert the ATmega328P and burn the bootloader. You have two options:

  • Use another Arduino as a programmer. Upload the “ArduinoISP” sketch to a working Arduino, wire it to the ISP header on your new board, then in the Arduino IDE go to Tools → Programmer → Arduino as ISP → Burn Bootloader.
  • Use a dedicated ISP programmer (USBasp, Atmel-ICE). Same process, different hardware.

Once the bootloader is burned, connect an FTDI USB-to-serial adapter to your board’s programming header. Select the correct COM port in the Arduino IDE. Upload a blink sketch.

The LED blinks. Your sensor reads. Your motor spins. This isn’t a breadboard anymore. It’s your board.

Your First Revision Is Already Taking Shape

Your first custom PCB will have something wrong with it. A footprint that’s slightly off, a trace that should have been wider, a connector that faces the wrong direction, a mounting hole you forgot. This is normal. Professional hardware engineers budget for board revisions. They call them Rev A, Rev B, Rev C. Your first board is Rev A. It works well enough to prove the concept and reveal what to fix next.

Rev B will be dramatically better, because you’ve now been through the full cycle: schematic to layout to fabrication to assembly to power-on. You understand every component on the board because you placed each one deliberately. That understanding, knowing why the crystal needs 22pF caps, why the decoupling capacitor sits next to the VCC pin, why the reset line needs a pull-up, makes you a better maker on every future project.

Save your KiCad project files. Start a simple changelog. And when you’re ready, start thinking about what that next board could do: a different MCU, integrated USB, SMD components for a smaller form factor, or designing for small-batch manufacturing. The path from Arduino to PCB is also the path from hobbyist to hardware designer. You just took the first step.

Hubble Network enables Bluetooth connectivity from custom PCBs directly to satellites—no gateways, no cell towers, no infrastructure buildout. See how it works →