From Idea to PCB: ESP32‑C3 Prototyping with Free Tools

Have you ever opened a drawer and found that component or development board you bought years ago for a project that never happened?

That’s exactly what happened to me with some LCD screens — they’ve been sitting in a drawer for more than 10 years. It was finally time to do something with them, and at the same time use the opportunity to write about KiCad, the ESP32, and what you need to know to build many electronics projects in 2025.

A lot has changed in the electronics world during those 10 years. One major shift is the huge improvement of the KiCad PCB design tool, and another is the massive adoption of Espressif’s low‑cost microcontrollers.

I had never seriously considered working with either of them, but after designing a simple PCB to evaluate both, they’ve now become strong candidates worth investing time in for future developments. Let’s start with Espressif’s microcontrollers.

ESP32.

Espressif is a Chinese microcontroller company focused on IoT devices. Unlike other manufacturers with hundreds or even thousands of MCU models, Espressif keeps a very small catalog—around 20 to 30 variants. Combined with massive production volumes (over one billion units sold), this allows them to offer some of the lowest prices on the market.

For this project, we’ll be using the ESP32‑C3, a 32‑bit microcontroller that can be purchased for less than one euro per unit from most mainstream electronics distributors.

For less than one euro, these are some of the main features you get in this microcontroller:

• A 32‑bit RISC‑V processor running at 160 MHz.
• 400 kB of RAM and 384 kB of ROM, plus an external 4 MB SPI FLASH chip for program storage.
• Built‑in Wi‑Fi and Bluetooth connectivity. This is the strongest point of the ESP32 family—no other manufacturer offers Wi‑Fi MCUs anywhere near this price. With other vendors, the cost of Wi‑Fi‑enabled microcontrollers is several times higher.
• A full set of common MCU peripherals (shown in the diagram above).
• An integrated USB‑to‑Serial/JTAG converter (disabled in some low‑power modes). What does this mean in practice? Simply by connecting the ESP32‑C3 to your computer via USB, you can debug your firmware without needing any external debugger. A single USB cable gives you everything you need to work with the chip—something that is not common with most microcontrollers.

When adding an Espressif microcontroller to your PCB, you have two options:

• Buy the bare microcontroller and add the external crystal, capacitors, FLASH memory, antenna matching network and connector (or draw the antenna directly on the PCB), plus all other required components. This is the option to choose when space is extremely limited.
• Buy a module such as the ESP32‑C3‑WROOM, which includes all of the above for about €2.8 per unit. In most cases, this is the preferred option unless space is critical, because buying all the individual components ends up costing roughly the same as the module—plus you avoid the extra design work and the RF considerations required for the antenna layout.

Buying a similar module from another manufacturer usually means paying two or three times the ESP32’s price, so becoming familiar with the ESP32 family is almost mandatory when building ultra‑low‑cost Wi‑Fi/Bluetooth electronics.

In the hobbyist world, ESP32 boards quickly replaced many Arduinos because they offered far more features at a much lower price, while still supporting the same ecosystem of libraries and programming environments.

However, price and hardware specs are not the only factors to consider when choosing a microcontroller. Equally important are the firmware libraries and development tools, the quality of the documentation, and the strength of the community. No matter how cheap the hardware is, it must be well documented, have usable libraries, and provide a community or manufacturer feedback channel to help solve issues. More on that later—first, let’s talk about KiCad.

For this project, we chose the ESP32‑C3 module option. We don’t have space constraints, and using the module saves design time, component selection effort, and assembly work, since we only need to solder a single module that already includes all required parts.

When working with a microcontroller for the first time, the first step is always to check the manufacturer’s documentation. It usually includes reference schematics and examples showing exactly how the device should be integrated into a PCB.

Manufacturers also provide ready‑to‑use evaluation boards for their microcontrollers, along with complete schematics. These boards are an excellent reference when you’re designing with an unfamiliar MCU for the first time.

Lastly, if the microcontroller has a large community, you’ll also find schematics and design files shared by people who have used and tested the device. These can be another useful source of information. However, the ideal references are always the first two: the official manufacturer documentation and the schematics of their evaluation boards. These are created by professionals who know the hardware inside out—or at least, they should.

KiCad.

We already have the project idea, the microcontroller we’re going to use, and plenty of reference designs showing how to integrate it into a PCB. Now we just need a PCB design tool to get started. After giving KiCad a quick try (I’m still far from an expert) while designing a small board for a workshop at a local MakerSpace in Alicante, I’d say that KiCad is currently the best option for anyone starting with PCB design.

KiCad is a PCB design tool that has been in development since 1992. In recent years, organizations like CERN have contributed to its development, resulting in a fully free PCB design suite with professional‑level features. It’s not (yet) at the level of high‑end commercial tools—whose licenses start around €3k–10k and go up from there—but for the vast majority of designs, you don’t need those expensive tools. KiCad is more than capable, fast, and absolutely suitable.

I’m currently using KiCad 9. I had tried older versions years ago and didn’t like them at all… but after testing version 9, my opinion has completely changed. If development continues in this direction, KiCad will end up becoming a standard for PCB design—if it isn’t already.

Some highlights worth mentioning (among many others I still haven’t explored):

• A much easier and more intuitive user interface compared to previous versions.
• Greatly improved routing tools (push‑and‑shove, obstacle avoidance, etc.).
• Solid integration between the schematic editor and the PCB layout tool.
• A large and active user community, making it easy to search for answers or use the forums.
• And most importantly: even with minimal prior experience, I was able to route the PCB shown earlier quickly, without spending time figuring out how things worked or digging through documentation.

Another very important factor when choosing a PCB design tool is the availability of component libraries. Whenever we need to use a component, we want to have its schematic symbol ready to drop into the design, its footprint for the PCB layout, and ideally its 3D model (not essential unless we need to export the PCB for mechanical integration).

Today, thanks to platforms like SnapEDA, it’s much easier to find the components you need without spending time creating symbols and footprints from scratch. In addition, Digi‑Key (an electronics distributor) has recently added models for many of the components they sell directly on their website. This means that while you’re searching for the symbol and footprint (if they’re not already included in your design tool’s libraries), you can also add the component to your cart—assuming the price is competitive with other distributors.

Manufacturers and distributors have a strong interest in making all component models available. If your design has two possible component options (similar specs, price, availability, etc.) and only one of them provides ready‑to‑use symbols and footprints, you’ll almost always choose the one that does—because it saves the time required to create those assets manually. And if those models are available directly on a distributor’s website, the chances of ordering from that distributor increase, since you can simply add the part to your cart while searching for the library files.

To summarize everything so far: this project started with a microcontroller I had never used before and with KiCad, which I had barely touched in the past. The experience with both has been excellent. The ESP32 documentation is solid, the community is large, and integrating the ESP32‑C3 module into a PCB was quick and straightforward. Likewise, KiCad proved more than capable of handling the PCB design efficiently and without friction. Overall, the hardware design experience using the ESP32‑C3 and KiCad has been outstanding.

Note: this board was designed over just two weekends (around 3–4 days) from the moment I pulled the LCD out of the drawer and decided what to build with it. I moved very fast—so don’t use this design as a reference—and there are several areas that could be improved with more time spent on layout and refinement

PCB Assembling.

Once the PCB design is finished, we generate the Gerber files and send them to our preferred manufacturer—usually a Chinese PCB factory due to cost. If you’re not sure how to generate Gerbers, simply searching “KiCad + manufacturer name” will usually take you to the PCB vendor’s own guide explaining how to export the files correctly.

After generating the Gerbers and sending them for fabrication, we have two options:

• Order the PCB with all components pre‑assembled: this is expensive. While PCB fabrication is extremely cheap, the assembly service—buying the components and soldering them onto the board—is much more costly and often takes several weeks.
• Order bare PCBs: receive them in 1–2 weeks and solder the components yourself.

Soldering the components is a very simple process, and you can learn everything you need in just a few hours. However, due to the small size of modern components, having the right tools is essential.

The easiest way to assemble a prototype is to use a small reflow oven or a hot plate. The process works as follows (click the images for a larger view):

• Place the PCB stencil (ordered together with the board) on top of the PCB to apply the solder paste.

• Using tweezers, place the components onto the PCB.

• Place the PCB with the components into the reflow oven to obtain the finished prototype.

Once the SMD components are soldered, any through‑hole parts can be soldered by hand. With the right tools, soldering is a simple process that allows you to build prototypes quickly and at low cost, so it’s definitely a skill worth having.

With the board assembled, we’re ready to test it. After taking a few basic measurements with the multimeter, the first step is to write a small test program for the microcontroller to verify that the hardware behaves as expected.

And this is where the most important part of working with microcontrollers begins: the tools and libraries used to develop the firmware. Firmware development is usually the most time‑consuming part of any project, so having good tools and a solid ecosystem makes a huge difference

Programming the Microcontroller.

In most microcontroller‑based electronics projects, firmware development takes up the majority of the time. This means that if the documentation or development tools are not adequate, it doesn’t matter how cheap or powerful the microcontroller is—the development time will end up costing more than simply choosing a slightly more expensive MCU with better libraries and tooling.

To program the ESP32‑C3, we’ll use Espressif’s official libraries and documentation (ESP‑IDF) along with VS Code. If you prefer working from the command line, you can also use Espressif’s tools without VS Code.

• Download and install VS Code.
• Install the ESP‑IDF extension for VS Code.
• On Windows, download the required USB driver from Espressif’s website to enable on‑board debugging over USB.
• Go to Espressif’s documentation portal, where you’ll find the libraries and guides for programming the microcontroller.
• You’ll also need the FreeRTOS API, since ESP‑IDF uses FreeRTOS by default.

Once everything is installed, opening VS Code brings up the ESP‑IDF welcome screen, where you can create a new project for the ESP32 you’re using, load examples, and more.

There are other alternatives for programming ESP32 devices, such as Arduino or PlatformIO, but I haven’t explored them. Personally, I prefer using the manufacturer’s official libraries without additional abstraction layers.

By default, ESP‑IDF (Espressif’s official IoT Development Framework) runs on top of FreeRTOS. When you reach the main.c file of your project, FreeRTOS is already running underneath.

FreeRTOS is one of the most widely used RTOSes for microcontrollers and helps structure applications more easily. Modern MCUs have hundreds of kilobytes of RAM and several megabytes of Flash, and they handle communication stacks like Wi‑Fi, Bluetooth, LoRa, and more. In most applications, it makes little sense not to use an operating system to manage all the tasks the microcontroller must perform.

Knowing how to break an application into tasks, how to use the different RTOS components, and how to structure your code around them is essential when working with today’s microcontrollers.

From VS Code, we can access the ESP Component Registry, where we can find reusable code libraries. For example, if we want to use a temperature sensor, we can create the .h and .c files for that sensor and, along with configuration and dependency files, package them into what Espressif calls a “component.” The Component Registry already includes many ready‑made components that we can download and use in our applications. A component is simply a library bundled with configuration files, usage examples, and a dependency file—everything neatly packaged into a single unit

To verify that our hardware is working correctly, we wrote a quick test program, which can be found in the prototype’s repository. In this code, we display a few lines on the LCD using the SPI bus, read the push buttons, and activate the board’s buzzer. Over the I²C bus, we read and write to the different ICs connected to it to confirm that they are functioning properly. All sensor readings are sent over USB and displayed in a VS Code terminal.

By pressing the debug button, we can start a debugging session without needing any additional hardware between the PC and the microcontroller. This allows us to pause the program at any line of code, inspect MCU registers, variables, stacks, and more. Having a debugger is essential when developing firmware, and in the ESP32‑C3 it comes built‑in.

The chip also includes pins for connecting an external debugger, since the internal one is disabled in some of the microcontroller’s low‑power modes.

With zero cost, we now have all the software tools needed to work with the ESP32‑C3. These are professional‑grade tools that allow us to develop any kind of project—or, as in the case of this board, to run a workshop on embedded programming with everything required to learn effectively.

When it comes to Espressif’s libraries and development tools, the first impression couldn’t be better. Following their documentation—seeing it for the first time—the SPI bus was up and running almost instantly, and the same was true for the I²C bus when communicating with the ICs connected to it. All the tools for flashing, debugging, and interacting with the microcontroller worked flawlessly from within VS Code, one of the best IDEs for software development. Hard to ask for more at a cost of zero euros.

Note: just like the hardware, the code in the prototype repository is a quick test implementation created in a hurry—don’t use it as a reference.

Conclusions.

In this blog post, we’ve built an electronic prototype for under €100 (€50 in PCBs and €50 in components). The result includes Wi‑Fi and Bluetooth connectivity, a graphical LCD, a battery with proper management, and a microcontroller with megabytes of program memory and hundreds of kilobytes of RAM running an RTOS. And on top of that, all the hardware and firmware development tools we used are completely free—something that not long ago would have required thousands or even tens of thousands of euros.

Regarding KiCad and Espressif microcontrollers, the first impression couldn’t be better. Both are absolutely worth investing time in if you’re planning to develop electronics projects.

We could even say that building electronics today is cheaper and easier than ever. The trade‑off is that the knowledge base required keeps growing, mainly because of the increasing amount of software our devices now run. How much code does a modern car contain compared to one built 20 years ago?

Where there used to be a simple circuit, now there’s a programmable module. Microcontrollers keep gaining processing power, memory, and communication stacks, which means the devices we build have more features—and run far more lines of code—than ever before.

What do you need to know to build a project with a microcontroller like the ESP32?

• Basic electronics knowledge to design a schematic and select and connect all the components. You’ll always encounter analog electronics, digital electronics, and power electronics.
• How a microcontroller works, along with a basic understanding of its architecture.
• PCB design and routing. You should know how to use a tool like KiCad and understand concepts such as controlled‑impedance traces, when to use termination resistors, some basic EMC considerations, and other principles that are essential in most modern microcontroller‑based PCBs.
• PCB soldering, so you can build prototypes quickly and cheaply. This is actually the easiest part—learning how to assemble a PCB only takes a few hours, although you do need the right tools.
• Programming: you should know C and ideally C++ (and later other languages like Python or Rust). You need to understand how to use an RTOS such as FreeRTOS or Zephyr, and follow good programming practices to write portable and maintainable code. You also need to know how firmware is built and debugged.

Mastering all of the above can be challenging. If you’re strong in electronics but not in programming, you won’t be able to complete a project with a microcontroller like the ESP32. On the other hand, if you’re strong in programming but not in electronics, you can always rely on the thousands of ready‑made boards available for electronics projects and simply connect them together.

If you’ve read this far, I hope it was useful. Thank you.

This is an automatic English translation; the original article in Spanish can be found at the following link.