How to Build Your Own PC: A Component Compatibility Guide

Are you planning to build your own PC instead of buying a prebuilt one? If something is holding you back, it is probably not the screwdriver work. It is standing in front of a wall of parts and not knowing which ones actually work together.

That is genuinely good news, because compatibility is not a matter of luck, intuition, or years of experience. Every manufacturer publishes exactly what its part works with, which means the whole question can be settled on paper before you spend anything. A processor, a motherboard, memory, a graphics card, storage, a power supply, and a case all have to agree with each other on socket, chipset, form factor, and power. Get that agreement right, and the physical assembly turns out to be the easy part.

This guide is the component checklist I used to plan and build my own machine, an Intel Core i5-12600K paired with an RTX 3070 Ti. It runs in the order you should actually buy in, and I use that build throughout as a concrete example of every rule in action. By the end you will not only have a parts list, you will understand why each part is on it.

Why Compatibility, Not Assembly, Is the Real Challenge

#

Every component in a PC has to satisfy the requirements of its neighbors. The processor dictates the socket and chipset the motherboard needs. The motherboard dictates which memory type is even possible. The graphics card dictates how much power the supply has to deliver. The case dictates how large everything else is allowed to be.

None of that is guesswork. Manufacturers state exactly what is compatible with what, and once you know where to look, choosing parts becomes a series of small, verifiable decisions instead of a leap of faith. That is the mindset this guide is built around: read the specification, confirm the match, move to the next component.

Because each choice narrows the next one, the decisions come in a natural order:

1. The processor, which fixes the socket and the chipset generation.
2. The motherboard, which fixes the memory type and the physical size.
3. The graphics card, which fixes how much power the supply has to deliver.
4. The case and the cooling, which fix what physically fits and how well it breathes.

Although it is tempting to start with the graphics card, since that is the part everyone talks about, starting at the processor is what keeps you from backtracking later. Follow the chain in order and every component you add is already constrained by the ones before it.

How to Choose Every Component (and Why It Matters)

#

Processor: Let It Tell You the Chipset

#

Start with the processor, because it decides almost everything downstream. Every manufacturer states, right in the product specifications, which chipset generation the chip is compatible with. For Intel Core processors, that compatibility follows the socket and the chipset naming pattern: sockets like LGA 1151, LGA 1200, and LGA 1700 (12th generation), paired with chipsets that follow an H_x_10 / B_x_60 / Z_x_90 naming pattern, where x marks the generation. For AMD Ryzen, the equivalent pattern is A_x_20 / B_x_50 / X_x_70 on the PGA AM4 socket, with the caveat that the Ryzen 7000 series moved to an LGA socket and is no longer AM4-compatible.

In my build: I chose the Intel Core i5-12600K, a 12th-generation, unlocked chip on the LGA 1700 socket. Following the naming pattern above, that meant the motherboard had to be a 600-series board, in my case a Z690, the top tier of that generation (the Z tier in Intel’s own Z_x_90 pattern).

Motherboard: Socket, Chipset, and Physical Size All Have to Match

#

A motherboard has to clear three checks at once: the socket has to match the processor, the chipset has to match the processor’s generation, and the physical size has to fit inside the case. Sizes run from largest to smallest: EATX, ATX, mini-ATX, mini-ITX.

In my build: I picked the Gigabyte Z690 AORUS ELITE AX DDR4, an ATX board built around the Z690 chipset for LGA 1700. There is a detail in that name worth pausing on: this board comes in both a DDR4 and a DDR5 variant, and the two are not interchangeable, which brings us straight to the next component.

RAM: DDR4 or DDR5, the Motherboard Decides

#

The processor does not choose your memory type, the motherboard does, and currently no board supports both DDR4 and DDR5 at once. That choice gets made the moment you pick the board, not the moment you buy the memory. Moreover, the motherboard’s specification sheet states the maximum speeds it can actually reach, including any overclocked (OC) profiles, so it is worth reading before you pay for speed the board cannot use.

In my build: because I chose the DDR4 variant of the Z690 AORUS ELITE AX, my memory had to be DDR4 as well: Corsair Vengeance RGB Pro DDR4, 2 x 8 GB for 16 GB total, at 3600 MHz, and Intel XMP certified so the board can hit that rated speed without manual tuning.

Storage: M.2 NVMe or SATA

#

Modern storage mostly comes down to M.2 SSDs, which can be either SATA or NVMe (Non-Volatile Memory Express), alongside the older SATA 3 SSD form factor. Every M.2 slot is physically compatible with every PCIe generation, but check the exact generation your board supports, because that is what determines whether you actually get full performance out of the drive or just its floor speed.

In my build: I used a WD_BLACK SN850, a 1 TB NVMe SSD on PCIe Gen4, rated up to 7000 MB/s read. Matching a Gen4 drive to a board with Gen4 M.2 support, rather than to an older Gen3 slot, is exactly the kind of check that decides whether that rated speed is real or merely theoretical. Further down, in the measured results, I put that rated number to the test on this exact drive.

Graphics Card: Let It Size Your Power Supply

#

The graphics card connects through a PCI Express slot (3.0, 4.0, and so on), and here is a detail that saves a lot of headaches: every PCIe generation is backward compatible, so a newer card will run fine in an older slot. The number that actually matters for your build is power. Once you know the card’s peak power draw, the rule of thumb I follow is simple: the power supply should be rated at at least double that peak draw. A card with a 200 W peak, for example, calls for a supply of at least 400 W.

In my build: I chose a ZOTAC GAMING GeForce RTX 3070 Ti Trinity OC, with 8 GB of GDDR6X memory. That card is what sized the power supply for everything else.

Power Supply: Leave Room to Grow

#

A good power supply is modular where possible, since that means individual cables you only plug in if you need them, cutting down on clutter inside the case. Internally, look for separate PCBs for better efficiency, and decide between a single-rail and a multi-rail design. Further, think past the current build: leaving headroom for expansion is what keeps a future upgrade from forcing you to buy a whole new supply.

In my build: I went with a Corsair RM750x, 750 W, 80 PLUS Gold certified, and fully modular. Following my own rule of doubling the peak draw, that comfortably clears the mark for the RTX 3070 Ti while leaving real room to grow.

Cooling: Air or Liquid

#

Every build eventually asks the same question: air cooling or liquid? Both are valid answers, and the right one depends on the case, the processor, and how much you want to tinker with a loop.

In my build: I used a Cooler Master Hyper 212 RGB Black Edition, an air tower cooler that ships with its own RGB fan controller. It is the only CPU cooler in this machine, with no liquid loop involved.

Case: Fit, Airflow, and the Small Things That Add Up

#

A case has to satisfy more than looks: size, heat dissipation, and room for future expansion all matter. As a baseline, aim for a minimum of 2 fans, preferably 3 or 4. Before buying, confirm the graphics card and motherboard physically fit, and think ahead about temperatures once everything is installed. Beyond that, a few extras are worth prioritizing: removable GPU slot covers, proper cable management and protection, a tempered glass panel, dust filters, and a mid-tower form factor if you want the easiest balance of interior space and desk footprint.

In my build: everything went inside a Corsair iCUE 4000X RGB Tempered Glass Mid-Tower ATX, which houses the ATX motherboard with room to spare and checks essentially every item on that list.

Fans and RGB: Airflow, Static Pressure, and Balanced

#

Fans are not all interchangeable. Beyond the obvious spec, size (commonly 120 mm or 140 mm), fans are built for one of three jobs: airflow fans that move a general volume of air, static pressure fans engineered to push air through a restriction like a radiator or a dense filter, and balanced fans that split the difference.

In my build: the iCUE 4000X came with three front-mounted Corsair SP120 RGB ELITE Performance PWM fans, and I added a pair of Corsair iCUE Lighting Node CORE controllers to bring all the RGB lighting, the fans, the memory, and the cooler, under one software-controlled system.

A Quick Connector Cheat Sheet

#

Before you start plugging anything in, it helps to recognize what you are looking at:

• EPS 8-pin: powers the processor, separate from the motherboard’s main power.
• CPU Fan / CPU Optional headers: either 4-pin PWM (speed-controlled by signal) or 3-pin (regulated by voltage).
• RGB header: white, either 4-pin at 12 V or 3-pin at 5 V, not interchangeable with each other.
• 24-pin: the main power connector for the motherboard itself.
• USB-C and USB 3.0: USB 3.0 uses a different physical connector from USB 2.0, so check your case’s front-panel cable before assuming it will fit.
• SATA: for SATA drives and some optical or legacy peripherals.
• PCIe 16x or 1x: 16x for the graphics card, 1x for smaller expansion cards.
• M.2 connector: for your NVMe or SATA M.2 SSD, mounted directly on the motherboard.

The Finished Parts List: An i5-12600K and RTX 3070 Ti Build

#

Putting every decision above together, here is the complete parts list from this build, dated April 23, 2022:

Every line in that table traces back to a rule from the checklist above. The i5-12600K’s LGA 1700 socket forced a 600-series chipset, which is why the motherboard is a Z690. Choosing the DDR4 variant of that board is the reason the memory is DDR4 and not DDR5. The ATX motherboard fits an ATX mid-tower case. And the RM750x’s 750 W comfortably clears the “at least double the peak draw” rule for the RTX 3070 Ti. None of it is accidental, it is the same compatibility checklist applied one component at a time.

Assembly and First Boot: What to Do When There Is No Video Signal

#

Once every part is verified on paper, the assembly itself is mostly patient screwdriver work. The moment that really tests you comes later, when you press the power button for the first time and the screen stays dark. That happened to me, and knowing in advance how to work through it is probably worth more to you than any other section of this guide.

Update the BIOS Before You Trust the Board

#

Before anything else, I updated the motherboard’s BIOS. A firmware update is the one step that can, in principle, leave you with an expensive brick, so it deserves a deliberate decision instead of a reflex. In my case the risk was low, and for reasons I could verify in the board’s own specification: the Z690 AORUS ELITE AX supports Q-Flash Plus, which flashes the firmware directly from a USB stick with no processor, no memory, and no graphics card installed, and it carries DualBIOS, a second physical BIOS chip that can take over if the main one is damaged. A board that can recover from a failed flash without even a working CPU turns an intimidating step into a routine one.

Check for those two features on your own board before you start. If they are there, updating first is the cleaner order, because you begin from firmware that already knows about your processor instead of discovering a compatibility gap after everything is screwed in.

The First Power-On: No Video Signal

#

Then came the moment every first-time builder recognizes. I pressed the power button, the machine came to life, and the monitor answered with nothing at all: no image, just its red indicator light. No video signal.

My first suspicion was the graphics card. That is the natural reflex, since the GPU is the largest, most expensive, and most conspicuous part in the case, and it is the one the monitor cable plugs into. It is also, as it turned out, the wrong suspicion.

Isolate One Variable at a Time

#

Instead of taking the whole machine apart at once, I changed a single variable. I removed the RTX 3070 Ti and booted on the integrated graphics of the i5-12600K, which took the most complex component out of the equation entirely. Then I reseated both memory modules in the same slots.

It booted. With a picture on screen and the cause identified, I reinstalled the graphics card and the build was complete.

Only then, with a machine that was known to be stable, did I go into the BIOS and enable XMP, the memory profile that lets the modules run at the speed they are rated for instead of the conservative default the board otherwise falls back to. That is the step that turns the 3600 MHz printed on the memory box into a number the system actually uses. Leaving it for the end is a good habit in general: get the machine booting reliably first, and tune it afterwards, so that if a setting does cause trouble you already know everything underneath it was fine.

That is the whole method, and it is worth internalizing: change one thing, test, and only then change the next. A first boot that fails is not a verdict on your build, it is a system with one unknown in it, and every component you can remove or re-test shrinks the search.

Two Lessons Worth Carrying Into Your Own Build

#

• When a new build refuses to POST, suspect the memory before the graphics card. A module can look perfectly installed and still not be seated all the way down, and this is by far the most common cause of a dark screen on a first build. Reseating costs you five minutes, which makes it the cheapest hypothesis to eliminate. Notice, too, that the fix here was the same slots, not different ones: the problem was seating, not slot choice.
• A compatibility decision handed me a diagnostic tool I had not planned on. I chose the “K” version of the i5-12600K for its unlocked multiplier. Intel also sells a “KF” variant, the same processor without integrated graphics, and had I bought that one I would have had no way at all to get an image on screen without the very card I was trying to rule out. The integrated GPU became my second, independent path to a picture, which is exactly what let me isolate the problem in a single step. Although the benefit was accidental, the habit behind it is not: choosing the part that keeps more options open tends to pay you back in situations you did not anticipate.

Measured Results: Temperatures, Power Draw, and Real Throughput

#

Planning a build on paper is one thing, and living with it is another. So if you are wondering what a machine assembled this way actually delivers, here are real measurements taken on this same computer, years after it was assembled and with the same air cooler it shipped with. Every figure below comes from the hardware’s own instrumentation under a controlled load, and I name the tool in each case, because a stated measurement method is what separates a measurement from a claim.

One more thing worth knowing before you read the numbers: this is a stock machine. The BIOS I flashed on the day I built it in 2022 is the same firmware it has been running ever since, and beyond enabling XMP I left the firmware alone. No overclocking, no tuning, just four years of ordinary use. That is precisely what makes these figures useful if you are planning a similar build, because they are what a comparable machine gives you out of the box rather than the reward of a tuning session.

The CPU: How the Hyper 212 Handles the i5-12600K

#

The test was a sustained load pinning all 16 threads of the i5-12600K at 100%, with the board’s sensors read by HWiNFO in sensors-only mode logging to CSV, sampled over a five-minute steady-state window (150 samples).

Around those two numbers, four results matter more than the temperatures themselves:

• The hottest single core reached 62.8 °C on average, peaking at 64 °C. The i5-12600K’s TjMAX, the temperature at which it starts protecting itself, is 100 °C. With the cores averaging 54.6 °C, that leaves roughly 45 °C of thermal headroom (100 − 54.6 ≈ 45).
• Zero thermal throttling and zero power-limit events across all 150 samples. The processor was never once forced to slow down.
• The P-cores held 4500 MHz for the entire window, with no drop. Sustained clocks are the real proof that a cooler is keeping up, because a cooler that cannot will show up as falling frequency long before it shows up as an alarming temperature.
• It returns to idle temperature in under a minute once the load is removed.

In other words, a well-chosen air tower, not a liquid loop, was enough for this processor under a heavy real workload. That is a useful data point if you are weighing the same trade-off and wondering whether air cooling is a compromise.

One honest caveat about that load. The work was openssl speed rsa2048, forked once per thread: heavy, realistic, and entirely integer. It drew about 99 W, which is below the chip’s 125 W rating, so a Prime95 small-FFT run or an AVX-512 torture test would certainly run hotter. Read these numbers as sustained real load, not as a worst case, and treat any figure you find online the same way: a temperature without its workload attached does not mean very much.

And one honest caveat about the board. HWiNFO reported both power limits, PL1 and PL2, as 4095 W, which is how it says there is no limit at all: the Gigabyte board ships with Intel’s power limits removed, even though the i5-12600K’s own specification is 125 W PBP and 150 W MTP. Under this workload it changed nothing, since the chip only ever asked for about 99 W, but under an AVX-heavy load it certainly would, and it is also part of why the “zero power-limit events” line above reads the way it does: there was no limit there to hit. If you build on a similar board, it is worth opening a monitoring tool once and checking whether the ceiling your processor runs against is Intel’s decision or your motherboard’s.

The GPU: The RTX 3070 Ti Under AI Inference

#

For the graphics card I used a load it now runs regularly, serving local language models through Ollama, and read the card’s own telemetry with nvidia-smi sampled during sustained inference.

Under that load the card held between 1920 and 1935 MHz. Additionally, 60 °C on a GPU working steadily is a comfortable place to be, and it says as much about the case airflow, with three front fans feeding the card, as it does about the card’s own cooler.

Was the 750 W Power Supply the Right Call?

#

This is where the measurements pay back the planning, because that 248 W figure is the missing input for the sizing rule this whole guide is built on. Adding the parts up:

• 248 W measured at the graphics card under sustained load
• 150 W maximum turbo power for the i5-12600K
• ~50 W for everything else: the drive, the fans, the memory, the board itself

That comes to roughly 450 W of estimated peak draw against a 750 W supply, which puts the machine at about 60% of the supply’s capacity at its busiest. Call this an estimate and nothing more, since I measured the components individually rather than the whole system at the wall socket, and a proper number would need a plug-in power meter. Even so, it confirms the rule: doubling the graphics card’s peak draw produced a supply with genuine headroom, enough for a future GPU upgrade without a second purchase.

What That Hardware Actually Produces

#

Numbers about heat and watts are only interesting because of the work underneath them. Generating 200 tokens at temperature 0 through Ollama on that RTX 3070 Ti, with the throughput taken from Ollama’s own timing fields on its /api/generate endpoint (eval_count divided by eval_duration) rather than from a stopwatch or a third-party benchmark:

The drop on the last one is the most instructive line in the table. A 6.6 GB model against 8 GB of VRAM leaves almost no room to work with, and the throughput falls off accordingly. It is the same lesson as every other section of this guide, arriving one more time: the specification you chose at purchase, in this case 8 GB of GDDR6X, is the ceiling you eventually meet in practice.

Storage: What the SN850 Actually Delivers

#

The box promises up to 7000 MB/s read, and putting a number like that to the test takes one precaution. With 32 GB of RAM in the machine, an ordinary read would be answered by Windows’ file cache, and I would have measured my memory instead of my drive. So I wrote and read a 4 GiB file on C:, which is the SN850 itself, with the cache bypassed (FILE_FLAG_NO_BUFFERING), forcing every request to reach the device. The method is what makes the figure real, and it is the difference between a benchmark and a number that flatters you.

Two results in that table are worth more than the headline speed:

• The buffer size swings the read by 43%. Going from a 1 MiB buffer to a 16 MiB one takes the drive from 4,098 to 5,841 MB/s (5,841 ÷ 4,098 ≈ 1.43). With small requests the bottleneck is not the drive at all, it is the latency of each individual request, so a benchmark that reports a “slow” NVMe may simply be asking for the data in pieces too small to keep the drive busy.
• Writes essentially reach specification, reads do not. The write lands at 95% of its rating (5,031 ÷ 5,300 ≈ 0.95), while the best read reaches 83% of the 7,000 MB/s on the box (5,841 ÷ 7,000 ≈ 0.83). The most likely reason is not the drive’s age: it was 97.3% full, with 25.5 GB free out of 930.5 GB. A nearly full SSD has no room left for its SLC cache and none for the garbage collector to work in, and both of those are what the rated figure assumes. If you take one practical habit from this section, make it that one: a nearly full SSD is a slower SSD, so leave it real free space.

As for the drive’s condition after four years of daily use, its own health counters report 0% wear, 41 °C at the time of the test, and 84 °C as the highest temperature it has ever recorded. Endurance, at least on this workload, has not turned out to be the limiting factor.

How Long It Takes to Boot, and Where That Time Really Goes

#

Boot time is the specification everyone quotes and almost nobody measures properly, usually because a stopwatch and a bit of optimism are involved. Windows, however, keeps the record itself: the Microsoft-Windows-Diagnostics-Performance/Operational log writes an event 100 for every boot, with the phases already separated. Reading it back gave me 12 real boots between July 18 and August 11, 2026, no stopwatch anywhere.

Across those 12 boots the main path ranged from 17.3 to 38.4 s and the total from 44.1 to 76.5 s, with zero boot-degradation events recorded.

The interesting part is not the total, it is the split. The stretch that actually depends on the components this guide is about, the NVMe drive and the processor, is roughly 20 seconds. The other 36 seconds are programs I installed loading after the desktop has already appeared. In other words, this machine is not slow to boot because of the hardware I chose so carefully, it is slow to boot because of what I put on top of it. That is worth remembering the next time a computer feels sluggish at startup: the parts list is rarely the culprit, and the startup list usually is.

What You Gain by Building It Yourself

#

The finished machine is only half of the reward. The other half is that you come out the other side actually understanding your own computer, first-hand rather than from a spec sheet: why a socket has to match a chipset, why memory type is a motherboard decision instead of a preference, and why a power supply’s wattage is an engineering constraint instead of a number to eyeball.

Concretely, working through this checklist gives you four things that a prebuilt machine rarely does:

• A computer matched to what you actually do, because you chose every part against your own workload instead of a marketing bundle.
• Knowledge that transfers, since reading a specification sheet and verifying a claim is the same skill whether the part is a motherboard, a microcontroller, or a sensor.
• An upgrade path you designed on purpose, from the spare wattage in the supply to the free slots on the board.
• The confidence to open it again, because a machine you assembled is a machine you can diagnose, clean, and repair.

For me, applying my own checklist to a real purchase (an i5-12600K, a Z690 board, DDR4 memory, and a power supply sized correctly for the RTX 3070 Ti) was the proof that the method works end to end and not just on paper. Every component arrived already verified against its neighbors, so nothing in that box was ever a gamble.

The Trade-offs Worth Naming

#

No build is a set of purely optimal choices, and being honest about the trade-offs is part of the engineering:

• DDR4 instead of DDR5. The same Z690 AORUS ELITE AX exists in a DDR5 variant. Choosing the DDR4 version meant building on the mature, widely available memory standard of the moment, at the cost of not being on the newer platform.
• Air cooling instead of a liquid loop. The Hyper 212 is a simple, low-maintenance tower with no pump and no coolant to worry about, and it is a different design point from a liquid loop.
• A supply sized for the future, not just for today. Doubling the peak draw means paying for wattage the current build does not use, and that headroom is exactly what makes a future upgrade a component swap instead of a second purchase.
• A mid-tower instead of a compact case. It occupies more desk space than a mini-ITX build, and in exchange it gives room for the ATX board, the air tower, the front fan array, and whatever comes next.

What This Project Taught Me

#

What stayed with me is not the parts list, it is the habit behind it: go to the primary source, verify the claim, and only then commit. Additionally, this build was a good reminder that a computer is a system rather than a pile of parts, and that the interesting constraints always live at the interfaces between components, in the socket, the memory standard, the power budget, and the physical volume of the case. That is the same instinct I bring to embedded systems and to any project where curiosity, patience, careful reading, and a willingness to be wrong on paper before being wrong with money all pay off. Each mistake caught in the planning stage is simply one you never have to pay for in hardware.

What I’d Explore Next

#

• Overclocking the i5-12600K, since it is an unlocked K-series chip and the Z690 AORUS ELITE AX supports it.
• A DDR5 platform on a future build, now that DDR5 boards and memory have matured since this one.
• Deeper cable management, using the iCUE 4000X’s routing channels to get the interior as clean as the RGB lighting deserves.
• Fine-tuning the fan curve and RGB lighting through Corsair’s iCUE software, now that the Lighting Node CORE controllers are in place.
• Getting the memory back to its rated speed. I have since added a second pair of sticks from a different kit, and the board settled all four at the slower kit’s profile instead of the 3600 MHz the Corsair pair is rated for. Mixing kits costs you the faster one’s speed, which is a compatibility rule I learned after this build rather than during it. The clean fix is a single matched kit rather than two that merely coexist.

Once your machine is built, the more interesting question is what you point it at. This exact machine is the one running my private AI assistant: the same RTX 3070 Ti I sized the power supply around also serves local language models, entirely on my own hardware and without sending a single prompt to somebody else’s server. I walked through that whole setup in Deploy Your Private AI with Ollama.

If you are planning your own build, I would love to hear which components you are weighing against each other, and why.