My First PCB: 10 Mistakes That You Can Avoid During Design, Fabrication And Assembly

This blog is about my experience designing, fabricating and assembling my first PCB. It talks about my learning process, the software and various tools that I used, and the mistakes that I made. After reading this blog, you should be better prepared to create your own PCB, and avoid some common mistakes in the process. Let’s get started!

This blog assumes familiarity with basic electronics and what a PCB is. As a refresher, a Printed Circuit Board (abbreviated to PCB) is a fundamental electronic component consisting of a layer of conductive material (often copper) laminated over a non-conductive material (often plastic and fiberglass). The copper layer is selectively removed to form the connections of a circuit on top of the board. Components such as ICs, capacitors, resistors, diodes, are soldered onto the conductive layer to complete the circuit. Similar to a breadboard, it acts as a base to construct circuits, but unlike one, it is intended to offer a permanent and rugged assembly of components, rather than one that can be easily altered and experimented with.

This blog only talks about PCBs with one or two layers, as those are the most common for hobbyists and budding engineers to get started.

Why I Chose To Make a PCB For My Project

Before seeing the creation process of the PCB itself, it is helpful to build some context around the project that it was intended for, and why I chose to create a PCB for it.

The project that I was working on before this was a PWM Generator Circuit using digital logic. While there are many circuits on the internet to generate PWM Signals (often using the 555 timer IC and some resistors and capacitors), the goal of this project was to solely use solely digital logic ICs and techniques.

The first step in the process was to create a schematic on paper, to use while constructing the circuit. After spending some time thinking, I completed a very rough RTL Diagram (logic-level diagram) and sketched it out on a paper. This is shown below –

Paper drawing of rough RTL design of PWM Generator Circuit
Drawing of rough schematic on paper

Clearly, the drawing shown above is not what an electronics hobbyist/engineer would call a “schematic”, but I was impatient and didn’t really intend to share my work at the time. Also, I settled with the RTL diagram, and didn’t bother to create a component-level schematic because I didn’t think it necessary for constructing the circuit on breadboards (this would come to bite me later). On finishing, the circuit took up three full-size breadboards and looked like a rats nest because of the wires.

First circuit on breadboard using NAND Gates, XOR Gates, Timers/Counters, Transistors, Diodes and resistors, before building the PCB
First iteration of breadboard circuit

Obviously, this was a very delicate construction that would start falling apart very easily. Simply moving it from one table to another, or probing it with a multimeter/oscilloscope would cause either the wires to come loose, or the breadboards to start breaking apart. Something else I would discover quite painfully, was that one of the wires in the circuit was partially broken, leading to an unreliable connection. Because of this, the circuit would start and stop working seemingly randomly. Eventually, I grew tired of these issues and decided to rebuild the circuit on a fresh set of breadboards. The second iteration of the circuit is shown below –

Second circuit on breadboard using NAND Gates, XOR Gates, Timers/Counters, Transistors, Diodes and resistors, before building the PCB
Second iteration of breadboard circuit

The design had been updated to use fewer components, which brought the count of breadboards down from three to two. I also replaced the jumper wires with solid-core wires of the right lengths and shapes. Most of the wires were from a wire kit, but some were measured, cut and bent from a spool. Lastly, I replaced the old breadboards with slimmer ones (they were still full-size).

These improvements made the circuit much more compact, and easier to test. After making sure that it worked properly, I decided that I wanted to make it more permanent and even easier to carry around. These reasons motivated me to seek out techniques to make my circuit more permanent, which I narrowed down to three options –

  1. Direct Wiring
  2. Perfboard
  3. Printed Circuit Board

The first option involves arranging the components on a table and directly soldering wires between connected points. This can be trivially eliminated, as the circuit had far too many wires to feasibly solder point-to-point. This left the perfboard and the PCB as the only two options. The former had the advantage of having a lower cost, but would have taken a lot of time to assemble (because of having to cut and route a large number of wires). The latter would be far quicker to design and assemble, but would come at a greater cost and shipping time. I would have to carefully think which option to choose.

In the end, I decided to go with the PCB because I was already too tired of having to deal with the wires, having to repeatedly measure, cut, bend and solder them, then deal with the bugs they caused. Not having to do all this sounded a lot better than being able to save a couple of bucks! Additionally, I had never made a PCB before, and thought it to be a good opportunity to learn the same.

Workflow For Creating a PCB

After deciding to make the PCB, the only one thing left to do was… learning everything about designing and fabricating PCBs. At this point, I didn’t really know anything about PCBs at all, except for their purpose and what they were. I did have a fair bit of experience with Circuit Design and perfboards, which helped out.

When I started reading about the workflow for PCB design, I discovered the following high-level steps that had to be followed, which are listed in order –

  1. Designing the PCB in software (optionally simulating it)
  2. Choosing a Fabrication House and having them fabricate the PCB
  3. Assembling the PCB

Notably, step 2 can be different if you choose to etch the PCB yourself at home. I did find out how to do this, but decided that it was too tedious and unreliable an endeavor for my first PCB, and I was better off just having it made from a dedicated Fabrication House.

Some Fabrication Houses also assemble your PCBs before having them shipped, allowing step 3 to be skipped. I avoided this as I was confident in my soldering skills and didn’t want to spend the extra couple of bucks, since I had the components ready with me.

Designing the PCB Using EDA Software

The first step in the workflow was to design the PCB, for which I came across a variety of free and paid Electronic and Design Automation Software. An EDA is a software tool that is used to simplify and automate the creation and simulation of electronic circuits, Integrated Circuit design, PCB design and related tasks. EDAs largely vary from each other in terms of their user interfaces and scope of functionality, and factions have emerged, each one supporting their own preferred EDA (similar to IDEs in software development).

I also realized that I had already been using EDAs, namely Fritzing and TinkerCAD, without even realizing it. Anyways, these two are not too well suited for PCB Design, prompting me to explore other options. I came across Eagle, Altium, Proteus, Orcad, KiCad and EasyEDA. Since this was my first PCB, I didn’t want to commit a lot of money to the design process and decided to eliminate the paid options right away. This left me with EasyEDA and KiCad.

Both were fairly similar for my use, and it was a difficult decision to make. In the end, I decided to go with EasyEDA due to its browser-based interface, which seemed a lot more convenient to me. I was very impatient (this is a common theme in the full story), and didn’t really want to set up any software on my computer. I just wanted to finish my PCB as fast as possible, and the convenience of the browser-interface was too good to pass in this regard.

The next step was to study about the design process itself. After spending a few hours on the internet, I discovered that the process could be broken down into the following high-level steps –

  1. Schematic Design
  2. Component Placement
  3. Routing Tracks (and copper-pour)

I read a little about each of these, and proceeded to design the schematic in EasyEDA. This was where my impatience started to get the better of me, and I made my first mistake and wasted a lot of time.

In my haste, I had not bothered to read about the design process enough, and had taken all my component shapes for granted. The ICs I was using were all in dual-inline through-hole packages, while I had ignorantly chosen all sorts of different surface-mount packages in my schematic.

💡 Mistake 1: Choosing the right component, but with the wrong package, and trying to change this in the PCB Design Phase

As a result of this, I was left utterly confused when I switched from the schematic view my circuit to the PCB view.

EasyEDA component library open with SN74HC86 XOR Gates being displayed with different packages
EasyEDA component library
Same IC with different packages being shown in EasyEDA component view (all look the same)
IC outlines in schematic view
Same IC with different packages being shown in EasyEDA PCB view (all look different)
IC outlines in PCB view

I wasted a fair bit of time on this, as I kept trying to fix the component outlines in the PCB view itself. Finally, I read a little more about the component selection process, component distributors such as LCSC, Digikey and ElectronicsComp, and how components are chosen for a circuit. The process had three steps –

  1. Choosing an component that meets the requirements of the electrical design. For example, the 74HC86 and 74LS86 are both Quad 2-input XOR Gate ICs, but the former is better suited for low-power applications, while the latter is has builtin pull-up resistors. The right one should be selected based on the electrical design constraints.
  2. Choosing a package (shape) for the component that meets the requirements of the physical design. For example, the 74HC86 is available in 14-pin parallel through-hole and 20 pin square surface-mount packages. The former is suited for breadboards and soldering by hand, while the latter is smaller and flatter. The package of the IC is usually indicated by a suffix on the name of the IC, but this can vary between manufacturers.
  3. Choosing a distributor whose components meets the thermal, radiation and other miscellaneous requirements. This choice is not as important for hobbyist designs as it is for critical applications such as medical, military and aviation, but it still helps to be aware of.

After following these steps and fixing my mistake, I switched from the schematic view to the PCB view once again, seeing correct outlines for my components this time around.

The next step was to place all the components on the PCB area. I had read that it is a good practice to place connected components as close as possible (to minimize resistance), and to keep all tracks as straight as possible.

After placing the components, I started routing the tracks. I avoided using the auto-router because I wanted to develop my own judgement during this project. This is where I was once again utterly confused. Because of my lack of reading, I had assumed that the EDA stored connections point-to-point between components, and would translate the same to the ratlines in the PCB view. But what I saw was that the ratlines were drawn arbitrarily.

💡 Mistake 2: Insisting on connecting pins directly as they are in the schematic, rather than following the optimized ratlines made by the EDA

After reading about this, I came to understand that EDAs use the concept of a net, which was a collection of pins of components that were all connected to each other. While creating the schematic of the circuit, this would be implicitly handled by the EDA, while the user would only see the wiring (which was point-to-point). In the PCB view, the EDA would draw ratlines between the nearest pairs of pins connected to the same net, which may not be directly connected in the schematic view. This is helpful because it makes the connections shorter without changing the actual schematic of the circuit. This is illustrated below –

Connection shown in EasyEDA schematic view
Connection in schematic view
Ratlines shown in EasyEDA PCB view
Ratlines in PCB view

After this, I finished the process of routing connections relatively quickly, and added a copper-pour for the ground net. I didn’t use direct routing for this because the large area of the copper-pour would act as a heat sink for the circuit.

At this stage, it is important to mention that I took the width of my tracks for granted, which is very irresponsible for a PCB Designer. Tracks on the PCB are not made from ideal conductors, and possess some amount of resistance in real life. It is a good idea to use an online calculator (such as this one) to make sure that the resistance of your track is within the constraints of the design. I was lucky and my design eventually worked out. Otherwise, I would have had to start over from the schematic.

When I tried to export the fabrication files, however, a notification asked me to run something called the DRC before proceeding. I was once again left confused, but allowed it to run nevertheless. On finishing, it hit me with a hundred or so errors and warnings. As before, I spent time reading about this new term. The Design Rule Checker is a feature in PCB Design software that checks the PCB design against a set of rules that are specified by the designer. Every rule that the design does not follow, is reported as an error or warning by the DRC.

EasyEDA allows creating multiple rules per project, and having each net follow one of them. The parameters specified in a rule are –

  1. Track Width The minimum width of tracks belonging to a net that follow this rule (this is to ensure that the track can carry enough current).
  2. Clearance The minimum distance between any two objects (such as traces, vias, pads) that belong to a net that follows this rule (this is to ensure that no arcing/sparking/cross-talk happens between nearby signals, and that the fabrication house can successfully mill the tracks).
  3. Via Diameter The minimum diameter of the copper portion of all vias belonging to nets that follow this rule (this is to ensure that the via can carry enough current).
  4. Via Drill Diameter The minimum diameter of the drilled potion of all vias belonging to nets (this is to ensure that the Fabrication house can successfully drill and plate the via).
  5. Maximum Track Length The maximum length of a track belonging to the net that follows this rule (this is to ensure that resistance of a track does not exceed a limit and degenerate the signal it carries).

My vias and tracks lengths were all under order, and my issues were caused by either improper clearance (majority), or improper routing (minority). The latter occurred because I had copied certain tracks and pasted them without changing the net to which the track belonged. The DRC didn’t realize that the track was for connecting a different pair of points and would give an error. This was an easy issue to fix.

Image of two ICs in PCB view, each having a ratline from the same pin to a pad, symmetrical
Ratlines before routing
Image of two ICs in PCB view, one having a ratline from a pin to a pad, and the other one having a connection from the same pin to another pad
Routing one connection manually
Image of two ICs in PCB view, one of the ratlines has been manually routed, and copied and pasted to the other one
Copying the track for another connection
Changing the net of a track/route in PCB view in EasyEDA
The track still follows the old net
Image of two ICs in PCB view, each having a track from the same pin to a pad, symmetrical
Track issues resolved after changing net

The clearance issues were present in two places –

  1. Between tracks and vias/pads on a bus (a collection of parallel tracks).
  2. Between adjacent pins from whom tracks would directly bend 45 degrees, before extending out.
Image of Bus (6 parallel tracks) with clearance issues
Bus with clearance issues
Image of Bus (6 parallel tracks) without clearance issues
Bus without clearance issues
Image of two pads close together, with tracks passing very closely, causing clearance issues
Track bending away from Pin before extending
Image of two pads close together, with tracks extending outwards before moving close, avoiding clearance issues
Track bending away from Pin after extending

I wanted my tracks to look as aligned and symmetric as possible, and it took me some time to get everything just right. In hindsight, I would have saved a lot of time if I had read about and used the DRC during the routing process. This was my fourth mistake.

💡 Mistake 3: Not using the DRC frequently enough during the design process;ignoring its errors/warnings

Once the errors (and warnings) were resolved, I was finally able to export the fabrication files and save them to my computer.

This completed the design process, or so I thought at the time. As we will see three sections later, this was not the end of my design process and I had to face some trouble ahead.

Getting it Fabricated From a Fabrication House

The next step in the PCB creation workflow was to have the PCB fabricated. As mentioned before, I avoided etching the PCB at home because I didn’t trust myself to get it right, and I couldn’t be bothered to go out and buy the chemicals required.

My first preference was to have the PCB fabricated from JLCPCB, as I had heard quite a lot about their service and reliability. On uploading the design to their website, however, I was stumped once more.

I had believed that the process of ordering the PCB was as simple as uploading the design, selecting the color and paying (from watching too much Youtube). On the other hand, the options given on the website seemed almost as complicated as the EDA itself. I was completely ignorant about these and had to go to the internet and read up once more. Listed below are some important parameter that I came across, that PCB Designers should be familiar with –

  1. Base Material This is material that the non-conductive part of the PCB is made up of. This determines the strength, flexibility and thermal tolerance of your PCB. Most commonly, FR-4 (a composite of plastic and fiberglass) is chosen as the base material. Flexible PCBs can use the flex option, and PCBs that are required to specifically be strong can use aluminum. Different Fabrication houses may give more or less options, so make sure to choose this wisely.
  2. PCB Thickness This is the combined thickness of the all the PCB layers. The default of 1.6 mm was good enough for my design.
  3. Surface Finish This is the finishing of the exposed areas of the PCB which are to be soldered. HASL (and its lead-free variant) and ENIG are two commonly provided options. If the former is selected, exposed copper areas are covered with a thin layer of solder, which keeps the cost low, protects against corrosion and assists during soldering. If the latter is selected, the exposed copper areas are plated with a layer of nickel, and then gold, which makes the process more expensive, but keeps the surface more level (a requirement for small, fine-pitch components). I didn’t have any special requirements in this regard, and went with the lead-free HASL version instead.
  4. Copper thickness This is the thickness of the outer copper layer. This had me confused the most, because it was somehow measured in ounces (a unit of mass), rather than a unit of length. Eventually, I found out that the measurement was indirect, and the thickness was a resultant of the specified weight of copper being spread evenly over an area of 1 square foot. The default option was 1 oz (which was enough for my low-current tracks), but I opted to pay a little higher for 2 oz.
  5. Color of the Solder Mask This is the color of the solder mask that is applied onto the PCB. The solder mask is a layer of epoxy that covers the PCB surface (apart from the areas to be soldered). I went with green, because it was the default color and I had no particular preference.
  6. Single Board vs Panel This option specifies whether the PCBs are fabricated as single pieces, or on a panel. A panel is a sheet of standard size on which layouts can be etched and cut out. If the former is selected, the customer must specify the quantity of copies they want, and it is left to the Fabrication House to place the layouts on the Panels and cut them out. The cost is calculated based on the number of PCBs, and it is more expensive. If the latter is selected, then it is the responsibility of the customer to organize the PCB layout(s) onto a panel. The cost is calculated on the basis of the number of panels. I did not require too many copies, and selected 5 copies (the minimum amount) of the Single Board Option.

After selecting the right options, and seeing the shipping time, I was a slightly disappointed. This was because JLCPCB is in China, while I live in India (specifically, the southern region), and it was only natural for shipping to take a while. This motivated me to find Fabrication Houses closer to me, and I found one by the name of Lion Circuits, that too within my city itself. Their cost was only slightly (<5%) more, but shipping times were far lower.

I proceeded to pay, and had to wait for ~9 days for the PCB to arrive. They arrived in a cardboard box with plenty of bubble-wrap inside. The PCBs themselves were covered with shrink wrap/cling wrap for an extra layer of protection. Overall, I was quite pleased with the packaging and the quality of PCBs. The box and PCBs are shown below –

PCB packaged in cardboard box with paper springs and bubble wrap
PCB packaging
PCBs wrapped in cling-wrap/shrink-wrap
PCBs wrapped in shrink-wrap/cling-wrap

This completed the Fabrication process, but things had been going too smoothly for some time, and trouble was overdue.

Assembling the PCB

The first step in assembling a PCB is to visually inspect if all tracks, pads and vias were properly etched (no shorts or breaks), and all holes were properly drilled. As expected, I completely skipped this step and started soldering the components right away.

I started from the shortest component and moved to the tallest. This order was important because the component could only be soldered once it was placed on the PCB and the turned upside down. If the tallest component was soldered first, the shortest component would not be supported by the table below, and would simply fall out.

The first component I had to solder were IC sockets. While soldering the final socket, however, I ran into a problem. I noticed that its last remaining leg was missing, and realized what happened on turning over the PCB. I had pushed the socket’s legs into the PCB before aligning it properly. This caused the last leg to bend inwards instead of going through the hole. 15 of the socket’s pins had been soldered already and there was no way to pull it out without damaging something. There was no way to bend the leg back into the hole either, as it was firmly pressed flat against the surface of the PCB.

💡 Mistake 4: Not aligning components’ legs to the PCB before inserting them, putting them under mechanical strain and breaking them

Image of IC-holder placed in PCB, with one pin missing, bent backwards
Pin on the top-right is missing (before soldering)
Image of IC holder in PCB, with clear view of a pin being folded backwards and inwards
Pin on the right-side is folded backwards and inwards

This was a very silly mistake that could have easily been avoided. Nevertheless, I was determined to fix it as I didn’t want to backtrack and start soldering a fresh PCB. I visually inspected the difference between the solder pad and the pin and determined the gap to be small enough to be able to flow solder between. After applying a generous amount of flux between the two and setting my iron to its hottest temperature, I managed to successfully complete this endeavor and made sure the connection was firm through continuity testing with a multimeter.

Next, I managed to solder the resistors, diodes and transistors (without any mistakes, no less). The final component remaining were the header pins, which is where I messed up again. Many of my header pins had to be soldered individually (instead of in a straight row), which made it hard to align during soldering. The pins would not be perfectly perpendicular to the PCB surface and would lean to the side a little.

Image of header pin inserted into PCB, perfectly straight and perpendicular to the PCB
Straight pin
Image of header pin inserted into PCB, bent and not perpendicular to the PCB
Bent pin

This was fine electrically, as the connection remained firm and wires could still be attached to the pin, but I didn’t like the look of it. I attempted to have it stand erect by heating the pad for a long period of time and using tweezers to align the pin. While soldering the final header, however, this ad hoc process failed and I took out the entire pad itself.

💡 Mistake 5: Unceremoniously heating up a solder pad/track for too long, causing it to detach from the PCB and burn up

This was the 5v pad no less, which had no alternative pads either. I was absolutely devastated, but eventually thought of a solution. To resolve the issue, I soldered a small piece of wire between the header pin and the 5v pin of the neatest IC.

Image of a pin being extended with a metal wire after its pad has been burnt/ripped away from the PCB
Connecting a pin whose pad has been ripped out

This situation could have easily been avoided if I hadn’t needlessly tried to straighten the header pins before testing the circuit first. Nevertheless, I finished soldering all the components and making sure they were firmly connected.

This finished the assembly process.

It works… just kidding (testing, troubleshooting and debugging)

It was finally time for me to test my first PCB, and I was quite excited to be doing this. The first step I had to follow was to add the test circuitry. Before seeing the test-circuitry, it helps to see a high-level view of my circuit. Its different components/stages are listed below along with their inputs and outputs –

Register Unit8 input bits (switches)
1 latch input (button)
8 latched bits
Timer Unit1 clock input8 bits
Zero Flag Unit8 input bits (from timer)1 bit (whether timer value is 0)
Equal Flag Unit8 input bits (from register)
8 input bits (from timer)
1 bit (whether timer and register value are equal)
Pulse Generator Unit1 bit (from Zero Flag)
1 bit (from Equal Flag)
final PWM Signal

The test circuitry consisted of –

  • LEDs to view the output of the Register Unit, Timer Unit, Zero Flag Unit, Equal Flag Unit and Pulse Generator Unit.
  • Switches (with pull-down resistors) to control the register value.
  • A push-button to latch the register value.
  • Square Wave Generator (I used the function generator from an oscilloscope) for the Timer’s clock input
  • An oscilloscope to see the Zero Flag Unit, Equal Flag Unit and Pulse Generator Unit at high frequency
  • A multimeter to check instantaneous voltages at various points

While attaching these to the PCB, I realized another serious mistake in the design. In my haste, I had forgotten to add a pad for the final PWM Signal! The aim of the circuit was to generate PWM Signals, but I had forgotten to add a pad for exactly that! This had happened because of my next mistake.

💡 Mistake 6: Not adding solder pads in the schematic view; forgetting to add them in the PCB view

I had avoided adding any pads in my schematic view, thinking that it would clutter the diagram. What I had not realized, was that it was very easy to forget this in the PCB view, where the focus completely shifts from designing the circuit to routing tracks. What was most ironic was that I had added al lot of pads for debugging the circuit at intermediate points, but had forgotten to do so for the final output. Anyways, I decided to test the rest of the circuit and fix this in my next order.

The first test was of the Register Unit. This was done by storing all possible values between 0 and 256 in the register. Fortunately, register worked reliably in the first attempt itself.

The next test was of the Timer Unit. This was the easiest component to test, as it involved connecting a Square-Wave Generator to the timer and making sure that it counted up from 0 to 255. Bugs usually manifested in the form of haphazard increments during counting, and could be attributed to unstable power, or a noisy square wave.

The problem that I faced, however, was that the timer would not count at all. It would remain stuck at 0, no matter how slow or fast the Square-Wave was. My first guess was that the timer was not receiving adequate power, but I quickly ruled this out using a multimeter. My next guess was that the IC was broken. A quick test on the breadboard ruled this out as well. The only remaining place for an error was the PCB itself. To diagnose this, I set my multimeter to its continuity mode and used the following method –

  • Check if there are no shorts between pins that should not be connected (commonly happens during soldering between adjacent pins, or when tracks have low clearance and a drop of solder falls between them etc.)
  • Check if there is a firm connection between pins that should be connected (commonly happens when too less/more solder has been used, or if the PCB was not etched properly and some tracks broke etc.)
  • Make sure that all components with a polarity (such as diodes, transistors, electrolytic capacitors, LEDs etc.) are connected in the right direction.
  • Make sure that all ICs are plugged in the right direction.

I checked all the pins of the timer one at a time, starting from 5v and ground, and moving to the other pins. With this technique, I narrowed down the error to the reset pin of the timer. The pin was supposed to connect to 5v, but was connected to ground instead. This was not a soldering error, but a mistake in my schematic. While transferring my pen-and-paper diagram to EasyEDA, I had accidentally connected the reset pin of the timer to ground instead of 5v. The IC that I was using had an inverted reset pin, i.e. it would be active when connected to ground instead of 5v. I had ignored the hash (#) symbol in the EasyEDA diagram for the circuit, which had caused the error. This was my next mistake.

💡 Mistake 7: Ignoring the # symbol (and other prefixes/suffixes) after pin names in EasyEDA (different EDA software can follow their own convention)

Image of schematic representation of timer IC, with # suffix on pins 9, 10, 12 and 14
Schematic representation of timer, with # suffix on pins 9, 10, 12 and 14

Note that different EDA software will use different conventions to indicate this, such as an apostrophe (’) or a tilde (~) either before or after a pin. Make sure to see the convention used by your preferred EDA software. This was a very careless mistake for which I wasted a lot of time. Anyways, I patched the issue by cutting the the ground track to the pin with a knife and drawing a wire directly to 5v from it, similar to the pad I ripped out.

After making sure that the timer counted properly, I moved on to the zero flag. This too did not work as intended, and would remain active all the time, not just when the timer was at 0. I used the previously mentioned technique once again, only to discover that one of the pins of a transistor was left floating, i.e. unconnected to anything. This was quite abrupt as the solder joint was firm and the PCB didn’t seem to have any flaws earlier. I was also unable to find any issue in the schematic or PCB design in EasyEDA. For some time, I was quite dumbfounded.

After some thinking, I decided it to inspect the other copies of my PCB and was quite disappointed by what I saw. The connection between the transistor’s pad and the ground plane had been milled away entirely. This is shown below –

Image of PCB-view in EasyEDA of a transistor's pads
All pins of transistor connected to tracks
Image of pads in PCB, one of the pad is left floating because of errors during fabrication
Right (rectangle) pin of transistor is unconnected

I had made two mistakes here.

💡 Mistake 8: Not inspecting a PCB before starting to assemble it

💡 Mistake 9: Ignoring the manufacturing limits and guidelines of your Fabrication House and not updating the Design Rules accordingly

If I had read the guidelines before creating the PCB (and consequently updated my Design Rules), the DRC would have reported this to me during the design process itself, thereby saving me a lot of time and money.

However, this was not too big of a problem, as I could simply scrape away a small portion of the solder mask from the ground plane and flow some solder between the faulty pad the exposed ground area. The Equal Flag Unit had this fault too, and I fixed it at the same time as I did for the Zero Flag Unit.

Image of PCB with solder mask lightly scraped off near a pin, to create an ad hoc pad
Solder mask scraped lightly to create ad hoc pad near pin

However, the zero flag still didn’t work after doing this. This time, it would activate for two value – 0 and 4. This could trivially be attributed to a faulty diode, which would act as an open circuit between the zero flag and the timer’s second pin (in binary, the second place has a value of 4). This was my next mistake.

💡 Mistake 10: Not thoroughly checking all components before soldering them to a PCB

While collecting components for the circuit, I had only checked the ICs and transistors, and had taken the resistors and diodes for granted. This was also a a relatively easy fix, and I had to simply de-solder the diode and replace it with a functioning one. I could have still saved some time by checking the components beforehand.

This fixed the Zero Flag Unit completely and I moved on to the Equal Flag Unit (I was excited to be nearing the end now). After verifying that the equal flag worked properly (no less thanks to fixing the faults in the zero flag), the only component left to test was the Pulse Generator Unit. Since I had forgotten to add a pad for the PWM Output, I temporarily soldered a short wire to the output of the IC and connected this to an LED.

This was the final remaining test… and it worked! I was very pleased that the final stage of the circuit worked on the first attempt itself. I checked the output for all possible values of the register and different frequencies for the timer, and verified that it worked well within my constraints.

The only thing left was to fix these issues in my design re-ordering the corrected PCB. The next few days felt like months, as I waited for the PCB to arrive. When it finally arrived, I quickly soldered all the components and made sure that it worked. My first PCB was finally complete!

The completed design is shown below –

Top-view of fabricates and assembled PCB (working)
Top of PCB
Bottom-view of fabricates and assembled PCB (working)
Bottom of PCB

Restating All Mistakes

Mistake 1: Choosing the right component, but with the wrong package, and trying to change this in the PCB Design Phase

Mistake 2: Insisting on connecting pins directly as they are in the schematic, rather than following the optimized ratlines made by the EDA

Mistake 3: Not using the DRC frequently enough during the design process;ignoring its errors/warnings

Mistake 4: Not aligning components’ legs to the PCB before inserting them, putting them under mechanical strain and breaking them

Mistake 5: Unceremoniously heating up a solder pad/track for too long, causing it to detach from the PCB and burn up

Mistake 6: Not adding solder pads in the schematic view; forgetting to add them in the PCB view

Mistake 7: Ignoring the # symbol (and other prefixes/suffixes) after pin names in EasyEDA (different EDA software can follow their own convention)

Mistake 8: Not inspecting a PCB before starting to assemble it

Mistake 9: Ignoring the manufacturing limits and guidelines of your Fabrication House and not updating the Design Rules accordingly

Mistake 10: Not thoroughly checking all components before soldering them to a PCB

Summarizing Good Practices And Debugging Techniques

Apart from the above mistakes, there are a lot more mistakes that a beginner can potentially make. Shown below is a brief list of best practices and debugging techniques to avoid or remedy PCB errors in general –

  • Always read all documents provided by your Fabrication House thoroughly to avoid being surprised (in a bad way) after paying for fabrication.
  • During schematic design, make sure to choose a descriptive name for each net. This reduces the possibility of creating a false connection
  • During schematic design, make sure to add all solder pads in advance. While routing the tracks, it is easy to forget that a pad/header must be added.
  • During PCB routing, make sure to mentally divide the PCB into stages and make sure that the input and output signals of each stage are under order. Especially take care of the first stage (which accepts inputs from outside the PCB) and the last stage (which supplies an output to outside the PCB)
  • Check passive components before soldering them onto the PCB using a multimeter. It is far easier to replace a component before it has been soldered onto the PCB, than after.
  • Avoid soldering ICs directly into a PCB. Try to use IC sockets as far as possible. This way, if an IC is damaged/burnt, you can simple insert another one, instead of throwing away the PCB or de-soldering and re-soldering a new IC.
  • If the PCB fails, try to gradually increase the granularity of the diagnosis. Divide the circuit into high-level blocks and check each block, rather than individual components. Narrowing down into the error gradually saves a lot of time. Also make sure to liberally add pads into the circuit for debugging (unless there is a constraint on size/price).

Most common errors in a PCB (assuming all components are working fine) can be fixed by using a the following method –

  1. Using the continuity-testing mode of a multimeter, check if all pairs of pins/pads that should be connected are indeed connected. There may be many such pairs, and it saves time to start from common points of failure (such as pins that are very far from each other).
  2. Using the continuity-testing mode of a multimeter, check if all pairs of pins/pads that should not be connected are indeed disconnected. There many be many such pairs, and it saves time to start from common points of failure (such as pins that are very close to each other).
  3. Using the resistance-testing mode of a multimeter, check if all resistors have the correct resistance and if all diodes are soldered in the correct direction.


After reading this blog, you should be better prepared to make your own PCBs, right from the design to the fabrication and assembly while avoiding many common errors. Feel free to leave any feedback or questions in the comments down below. Good luck!

4 thoughts on “My First PCB: 10 Mistakes That You Can Avoid During Design, Fabrication And Assembly”

  1. Absolutely amazing articulation of the entire process of creating your first PCB, Aditya! Anyone reading this should be able to pick up all your learnings and go from a novice to a pro in no time. I loved the way you optimized the design at every step from bringing down the breadboards from 3 to 2 initially, to reviewing every choice you made thereon..carefully analysing the pros and cons in each case. Despite knowing very little of Electronics, reading thro this kept me glued in anticipation of what the outcomes will be next. I must say that when everything worked with your final test, I felt the same joy that you must have experienced. Thanks to the detailed writeup that makes the understanding so immersive. Keep more coming 🙂

    On a side note – I have interviewed 100’s of software engineers in my career, and my way of finding good engineers is to provide them a problem and see how they solve it. I expect them to take me through the entire process of thinking from conceptualisation to design to coding and testing. I expect them to take me through their technical choices and why they made the decisions they made. Sadly you rarely come across candidates who truly “Think”. But I believe you know how to nail it 🙂

  2. Hello
    Mistake 7 is strange. The datasheet is the reference. Not the representation by EasyEda. The datasheet tells you exactly what to apply to or expect from a pin. Then DRC helps find ‘input not driven’ or ‘two outputs connected’ but cannot say if an input must be high or low.

    1. Hey Franck
      You are right in that the datasheet is the proper reference for the ICs functions and package, however the purpose of mentioning that mistake is not about misreading the datasheet.
      While constructing the initial circuit on the breadboard, I did follow the datasheet and get the circuit to work, but did not bother to remember the exact information about each net because I was mentally dealing with the RTL diagram most of the time.
      While routing the schematic, I did not take a close look at the pin names in EasyEDA and simply connected the reset pin to ground (logic low) so as to prevent the IC from being reset. The mistake was made here. After all, EasyEDA did mention that the reset pin was inverted, i.e. active-low. Even if it had not, I should have still noticed it and made sure to reconcile it with the datasheet. The purpose of mentioning the mistake is to ensure that beginners in a hurry don’t make the same mistake and make sure to check and double check their components pin names and reconcile them with the datasheet.

Leave a Reply

Scroll to Top