Upgrade and repair PCs and laptops safely

A user asks you to add 8 GB of RAM to speed up their laptop. You open the back panel and find the memory is soldered to the board. Another user wants their data on a new SSD, but their laptop has BitLocker on and no one knows the recovery key. Both tickets would have been easier if someone had checked compatibility and encryption before ordering parts or promising a deadline.

Hardware upgrades are simpler than they look, but they fail when preparation is skipped. By the end you will prepare a safe workspace, check compatibility before ordering, move data to a new drive without losing it, check battery health, and verify every upgrade before handing the device back.

Prepare a safe workspace before opening anything

Static electricity that you cannot feel can damage components. An ESD strapESD strap: A wrist strap that connects you to ground so static electricity drains away instead of discharging into components. Clip it to bare metal on the case, not a painted surface. or a grounded mat prevents this. Clip the strap to bare metal on the case or to a grounding point, not to a painted surface.

Before opening any device:

1. Shut down fully, not sleep or hibernate.
2. Unplug the power cable and any peripherals.
3. Disconnect the battery on laptops where the service manual says to. Some laptops have an internal battery cutoff in UEFI settings.
4. Press and hold the power button for a few seconds to drain residual charge.

Keep parts in their antistatic bags until you are ready to install them. Handle memory and cards by the edges, never by the gold contacts. Lay screws out in a pattern that matches where they came from; a phone camera is faster than a note.

Step through the whole preparation in order, from shutting down to the moment the case is safe to open:

Check compatibility before ordering parts

A RAM upgrade fails at the counter if the laptop’s memory is soldered. An SSD upgrade fails if you order SATA and the slot is NVMe-only, or vice versa. Compatibility is checked before ordering, not after.

For memory:

• Memory type: DDR4 and DDR5 are not interchangeable.
• Form factor: desktops use DIMMsDIMM: A dual in-line memory module: the full-size stick of memory used in desktop computers and servers. One module goes into one slot on the motherboard. More in “Inside a computer: CPU, RAM, board and GPU”, laptops use SO-DIMMsSO-DIMM: A small outline DIMM: the shorter memory module used in many laptops, mini PCs and all-in-one computers. It is not interchangeable with a full-size DIMM. More in “Inside a computer: CPU, RAM, board and GPU” or have memory soldered to the board.
• Maximum capacity per slot: a board that takes 16 GB per slot will not use a 32 GB stick.
• Channels: matched pairs enable dual-channel, which matters for integrated graphics.

For storage:

• Interface: the M.2 slot may carry NVMe traffic, SATA traffic, or support both protocols. Inserting a SATA-only drive into a slot that only carries NVMe signals means the drive will not appear in the OS.
• Length: M.2 drives come in 2230, 2242, 2260 and 2280 sizes. A 2280 drive does not fit a 2230 slot.
• Key: check the notch pattern matches.

The device maker’s spec sheet is the source of truth. If the user does not have it, search the model number. The example checks six parts against a sample spec sheet, one rule at a time:

# Checks parts against a laptop's spec sheet before anything is ordered.
# The spec sheet and the parts are samples; read the real values from the
# device maker's specifications for the model in front of you.

SPEC = {
    "memory_type": "DDR5",
    "memory_form": "SO-DIMM",
    "memory_slots": 2,
    "memory_max_per_slot_gb": 32,
    "storage_interface": "NVMe",
    "storage_m2_length": 2280,
}

MEMORY = [
    {"name": "DDR5-5600 32 GB SO-DIMM", "type": "DDR5", "form": "SO-DIMM", "gb": 32},
    {"name": "DDR4-3200 16 GB SO-DIMM", "type": "DDR4", "form": "SO-DIMM", "gb": 16},
    {"name": "DDR5-5600 64 GB SO-DIMM", "type": "DDR5", "form": "SO-DIMM", "gb": 64},
]

STORAGE = [
    {"name": "2 TB NVMe M.2 2280", "interface": "NVMe", "length": 2280},
    {"name": "1 TB SATA M.2 2280", "interface": "SATA", "length": 2280},
    {"name": "1 TB NVMe M.2 2230", "interface": "NVMe", "length": 2230},
]


def check_memory(part: dict) -> str:
    """Return OK, or FAIL with the first rule of the spec sheet the module breaks."""
    if SPEC["memory_slots"] == 0:
        return "FAIL  memory is soldered: no upgrade"
    if part["type"] != SPEC["memory_type"]:
        return f"FAIL  needs {SPEC['memory_type']}, got {part['type']}"
    if part["form"] != SPEC["memory_form"]:
        return f"FAIL  needs {SPEC['memory_form']}, got {part['form']}"
    if part["gb"] > SPEC["memory_max_per_slot_gb"]:
        return f"FAIL  at most {SPEC['memory_max_per_slot_gb']} GB per slot"
    return "OK"


def check_storage(part: dict) -> str:
    """Return OK, or FAIL with the first rule of the spec sheet the drive breaks."""
    if part["interface"] != SPEC["storage_interface"]:
        return (
            f"FAIL  slot is {SPEC['storage_interface']}, drive is {part['interface']}"
        )
    if part["length"] != SPEC["storage_m2_length"]:
        return (
            f"FAIL  slot takes {SPEC['storage_m2_length']}, drive is {part['length']}"
        )
    return "OK"


print("Sample spec sheet: DDR5 SO-DIMM, 2 slots, 32 GB per slot; M.2 2280 NVMe")
print()
for part in MEMORY:
    print(f"{part['name']:<25} {check_memory(part)}")
for part in STORAGE:
    print(f"{part['name']:<25} {check_storage(part)}")

Sample spec sheet: DDR5 SO-DIMM, 2 slots, 32 GB per slot; M.2 2280 NVMe

DDR5-5600 32 GB SO-DIMM   OK
DDR4-3200 16 GB SO-DIMM   FAIL  needs DDR5, got DDR4
DDR5-5600 64 GB SO-DIMM   FAIL  at most 32 GB per slot
2 TB NVMe M.2 2280        OK
1 TB SATA M.2 2280        FAIL  slot is NVMe, drive is SATA
1 TB NVMe M.2 2230        FAIL  slot takes 2280, drive is 2230

Only two of the six pass. The DDR4 module, the 64 GB module, the SATA drive and the short 2230 drive each break one line of the spec sheet, and each would have been a wasted order.

Encryption changes the plan

If the drive is encrypted with BitLocker or FileVault, you need the recovery key before you touch the hardware. A cloning tool will copy the encrypted data, but any boot change may trigger the recovery prompt on the new drive, and without the key the data is inaccessible.

For BitLocker: check Settings, Privacy & security, Device encryption to see if encryption is on. If it is, confirm the recovery key is stored in the user’s Microsoft account, in Entra ID, or on paper. The command manage-bde -status shows the protection status and the key protectors.

For FileVault: check System Settings, Privacy & Security, FileVault. The recovery key is either stored with Apple (signed in with an Apple Account during setup) or on paper.

The two systems are checked in different places, and the recovery key can live in different places too:

If the storage is built in and not replaceable, the path is a backup and migration to a new device, not a drive swap.

Clone or fresh install: when to use each

Moving a user to a new drive can be done two ways: clone the old drive to the new one, or do a fresh install and restore data from backup.

Cloning copies everything: the OS, apps, settings and data. It is faster when the old drive is healthy and the new drive is the same size or larger. Cloning a drive with errors may copy the errors.

Fresh install is cleaner: no old apps, no accumulated cruft, no unknown background services. It takes longer because apps must be reinstalled and settings reconfigured. It is the right choice when the old install is corrupted, slow, or full of software the user no longer needs.

Check battery health before promising a fix

A laptop that lasts only an hour on battery may not need a replacement: if the battery report shows the design capacity and the full-charge capacity are close, the battery is fine and the drain is software. If the full-charge capacity is half the design, the battery is worn.

On Windows, run powercfg /batteryreport in an elevated command prompt. It generates an HTML file in the current folder. The key figures are Design Capacity and Full Charge Capacity; their ratio is the battery health.

On macOS, System Information (under Hardware, Power) shows the Cycle Count and the Condition. Apple’s support article says a battery is considered consumed once it reaches its cycle-count limit, which is 1,000 cycles on modern Mac laptops. Recent macOS reports the condition in Battery settings as Normal or Service Recommended; older Macs, reached by holding Option and clicking the battery status menu, may instead show Replace Soon, Replace Now, or Service Battery.

The example reads four sample battery reports and works out each one’s health from the same two figures:

# Parses battery health from recorded reports.

SAMPLE_REPORTS = [
    {
        "device": "Windows laptop",
        "design_capacity_mwh": 57000,
        "full_charge_capacity_mwh": 52000,
        "cycle_count": 150,
    },
    {
        "device": "Older Windows laptop",
        "design_capacity_mwh": 48000,
        "full_charge_capacity_mwh": 24000,
        "cycle_count": 850,
    },
    {
        "device": "MacBook Pro",
        "design_capacity_mwh": 70000,
        "full_charge_capacity_mwh": 65000,
        "cycle_count": 320,
        "condition": "Normal",
    },
    {
        "device": "Older MacBook",
        "design_capacity_mwh": 54000,
        "full_charge_capacity_mwh": 30000,
        "cycle_count": 980,
        "condition": "Replace Soon",
    },
]


def calculate_health(design: int, full_charge: int) -> int:
    """Calculate battery health as a percentage of design capacity."""
    if design <= 0:
        return 0
    return round((full_charge / design) * 100)


def assess_battery(report: dict) -> str:
    """Return a human-readable assessment."""
    health = calculate_health(
        report["design_capacity_mwh"],
        report["full_charge_capacity_mwh"]
    )
    cycles = report.get("cycle_count", 0)
    condition = report.get("condition", "")
    
    if health >= 80:
        verdict = "Good condition"
    elif health >= 50:
        verdict = "Worn, consider replacement"
    else:
        verdict = "Significantly worn, replace"
    
    if condition in ("Replace Soon", "Replace Now", "Service Battery"):
        verdict = f"macOS says: {condition}"
    
    return f"{health}% health, {cycles} cycles - {verdict}"


print("Battery health analysis from recorded reports")
print("=" * 50)
print()

for report in SAMPLE_REPORTS:
    print(f"{report['device']}:")
    print(f"  Design capacity:      {report['design_capacity_mwh']:,} mWh")
    print(f"  Full charge capacity: {report['full_charge_capacity_mwh']:,} mWh")
    print(f"  Assessment: {assess_battery(report)}")
    print()

Battery health analysis from recorded reports
==================================================

Windows laptop:
  Design capacity:      57,000 mWh
  Full charge capacity: 52,000 mWh
  Assessment: 91% health, 150 cycles - Good condition

Older Windows laptop:
  Design capacity:      48,000 mWh
  Full charge capacity: 24,000 mWh
  Assessment: 50% health, 850 cycles - Worn, consider replacement

MacBook Pro:
  Design capacity:      70,000 mWh
  Full charge capacity: 65,000 mWh
  Assessment: 93% health, 320 cycles - Good condition

Older MacBook:
  Design capacity:      54,000 mWh
  Full charge capacity: 30,000 mWh
  Assessment: 56% health, 980 cycles - macOS says: Replace Soon

The older Windows laptop holds 24,000 of its 48,000 mWh design capacity, 50 %, so its battery is worn. The newer one holds 91 %, so a short runtime there points at software, not the battery.

A swollen battery is a stop-work condition. If the trackpad bulges or the case does not close, power off, do not charge, do not puncture or press, and hand it to an authorised recycler.

Verify every upgrade before handing the device back

Work through each check, and fix any failure before the device leaves the bench:

A CPU that runs hot after reassembly often means a loose cooler or missing thermal paste. Run a memory test even when the device seems fine: a bad stick that passes POST can still fail later and crash the system.

Practice

def battery_health(design_mwh: int, full_charge_mwh: int) -> str:
    """Return battery health verdict: good, worn, replace, or invalid."""
    # Your code here
    pass

from starter import battery_health

def test_good():
    assert battery_health(60000, 54000) == "good"  # 90%

def test_worn():
    assert battery_health(60000, 36000) == "worn"  # 60%

def test_replace():
    assert battery_health(60000, 24000) == "replace"  # 40%

Interview questions

These scenarios test your judgement on parts, repair safety and data protection. The first is a warm-up, answered here in full; weigh the risks and the recovery options of the other two before you open them.

Key takeaways

• Use ESD protection, shut down fully, and disconnect power before opening a device.
• Check memory type, form factor, capacity and interface before ordering parts.
• Confirm the encryption recovery key is accessible before touching an encrypted drive.
• Clone when the old drive is healthy; fresh install when it is not.
• Check battery health with powercfg /batteryreport or System Information before promising a fix.
• Verify capacity, run a memory test, and check temperatures before handing the device back.