Power supplies, UPS sizing and battery safety

A 3-year-old 650 VA UPS carries a 357 W office for 5 minutes before it drops. The desktops save their files in time, but the Wi-Fi router and the fibre ONT go dark with them, so cloud sync, voice calls and the alert that tells the team the mains are back all stop. Both outcomes come from a label the help desk could have read: VA, watts, battery energy and the three losses that pull the real runtime well below the sticker.

You will read a desktop power supply, pick between standby, line-interactive and double conversion UPS designs, size a UPS from a load’s watts and power factor, estimate honest runtime after inverter loss and battery age, choose between a surge protector and a UPS, and handle a swollen lithium-ion battery safely under India’s Battery Waste Management Rules.

A desktop power supply, from the socket to the board

A desktop power supply unitpower supply unit: The box inside a desktop computer that turns the mains voltage into +12 V, +5 V and +3.3 V rails for the board, drives and cards. Its short name is PSU. turns the mains voltage into the three steady low-voltage rails every part of a computer needs: +12 V for the processor, graphics card and drives, +5 V for older peripherals and USB ports, and +3.3 V for the chipset, memory modules and most M.2 cards. The label on the side of a modern retail unit names its rated total in watts and gives the amps each rail can supply, with an 80 Plus badge for the efficiency band it has been tested at (Bronze, Silver, Gold, Platinum and Titanium from the lowest to the highest). The watts figure is a cap on the sum across every rail at a given moment, not the sum of each rail at full load, so the arithmetic in a lesson example overshoots on paper and the real draw stays within the cap.

# A labelled 500 W PSU splits that budget across three rails. The program prints each rail's share, then adds up a
# typical office desktop's draw and compares it with the PSU's total. Numbers from a mid-range retail label; a lesson
# fixture, not a specific product. Standard library only, deterministic.

rails = [
    ("+12 V", 12.0, 36.0),   # the heavy rail: CPU, GPU, drives
    ("+5 V",   5.0, 20.0),   # legacy devices and USB
    ("+3.3 V", 3.3, 15.0),   # chipset, DIMMs, M.2 power
]

print(f"{'rail':<8}{'volts':>7}{'amps':>7}{'watts':>8}")
total_rated = 0.0
for name, volts, amps in rails:
    watts = volts * amps
    total_rated += watts
    print(f"{name:<8}{volts:>7.1f}{amps:>7.1f}{watts:>8.1f}")
print(f"{'sum':<8}{'':>7}{'':>7}{total_rated:>8.1f}")
print(f"PSU label total: 500.0 W (the label is a cap, not the sum of every rail at once)")

load = [
    ("CPU under a build",    80.0),
    ("integrated graphics", 15.0),
    ("NVMe SSD",             6.0),
    ("one SATA SSD",         3.0),
    ("DDR5 memory, 32 GB",   8.0),
    ("case and CPU fans",    6.0),
    ("motherboard",         18.0),
    ("USB keyboard+mouse",   2.0),
]
total_load = sum(w for _, w in load)
print()
print(f"{'component':<24}{'watts':>8}")
for name, watts in load:
    print(f"{name:<24}{watts:>8.1f}")
print(f"{'total':<24}{total_load:>8.1f}")
print(f"headroom at 500 W PSU: {500.0 - total_load:.1f} W, so a GPU drawing more than that cannot be added")

rail      volts   amps   watts
+12 V      12.0   36.0   432.0
+5 V        5.0   20.0   100.0
+3.3 V      3.3   15.0    49.5
sum                      581.5
PSU label total: 500.0 W (the label is a cap, not the sum of every rail at once)

component                  watts
CPU under a build           80.0
integrated graphics         15.0
NVMe SSD                     6.0
one SATA SSD                 3.0
DDR5 memory, 32 GB           8.0
case and CPU fans            6.0
motherboard                 18.0
USB keyboard+mouse           2.0
total                      138.0
headroom at 500 W PSU: 362.0 W, so a GPU drawing more than that cannot be added

The run shows a 138 W budget for a modern office PC without a dedicated graphics card: a processor, memory, two drives, fans, a motherboard and a keyboard and mouse account for every watt, so a 500 W unit leaves 362 W of headroom for a card the user might add later. The 80 Plus Bronze band means the PSU draws about 180 W from the wall to deliver those 138 W to the computer at 20 % load, 175 W at 50 % load, and so on; higher bands narrow the loss, which matters most for machines that run day and night.

Autosensing supplies accept any mains voltage from 100 V to 240 V, so the same unit works in India and in a country with 110 V service without a switch, while older units carry a red slider marked 115/230 V that must match the country or the next power-on becomes an invoice. Three connectors leave the PSU: a 24-pin cable with its 4-pin extension for the board, an 8-pin EPS cable for the processor and 6+2-pin PCI Express cables for graphics cards. Each slot’s plug shape is unique, which is why forcing a cable means it was the wrong one.

USB Power Delivery is the matching idea for laptops and small devices: a cable and a charger that negotiate up to 240 W over a full-featured USB Type-C link, as the USB Implementers Forum describes. Its data side belongs to the next lesson, Ports, cables, displays and docking stations.

Three ways a UPS carries you through a cut

An uninterruptible power supplyuninterruptible power supply: A unit that keeps a device running on battery when the mains fail or wander. Its short name is UPS. The three common designs are standby, line-interactive and double conversion. keeps a device running when the mains fail, but how it does it differs by design. The three shapes a help desk meets are standby, line-interactive and double conversion, and the price, the gap on a cut and the kinds of problems each covers follow from the path mains power takes through the box.

A standby UPS passes the mains through to the devices while a small charger tops up a sealed lead-acid battery. When a brownout or a cut drops the mains below a threshold, a transfer switch moves the load to the inverter and the battery, which takes two to ten milliseconds. Desktops, routers and most phones tolerate the gap; a handful of industrial controllers restart. A standby UPS is the cheapest kind, and most 600 VA to 1,500 VA units sold for Indian homes and small offices are standby.

A line-interactive UPSline-interactive UPS: A UPS that adds an autotransformer to trim a low or high mains voltage back to the right range without touching the battery, saving the battery for a real cut. adds an autotransformer that trims a low or high mains voltage back to the right range, so a brownoutbrownout: A drop in mains voltage below the specified range, often from heavy demand on the local supply, that can crash computers and damage motors over time. of 20 to 30 V no longer forces the battery to work. The battery is saved for a real cut, and the transfer time stays similar, two to five milliseconds. These sit under most office PCs and are a sensible step up from a basic unit where the mains voltage wanders.

A double conversion UPSdouble conversion UPS: A UPS that feeds the inverter from a DC rail all the time, so a load sees no gap at all when the mains fail. Also called an online or on-line UPS. rectifies the mains into a DC rail and builds a clean mains wave from that rail every moment, so the inverter runs all the time and the battery hangs on the same rail. The device sees no gap at all when the mains fail, because nothing changes except where the DC rail is fed from. The cost is a lower efficiency (about 92 to 96 % against the near 99 % of a standby unit) and louder fans, which is why double conversion is the choice for servers, medical equipment and small racks, not home desks.

Sizing a UPS: VA, watts and power factor

Every UPS carries two limits on its box, and both have to hold for a load to fit. The first is watts, the actual work the inverter and the battery must do, counted as volts × amps for a direct-current load or the time-average of volts × amps for an alternating-current one. The second is VAvolt-ampere: The apparent power a UPS inverter must build: the voltage across a load times the current it pulls, with no account of whether current and voltage are in step. Its symbol is VA. (volt-amperes), the apparent power the inverter must build; it is the voltage times the current the load pulls, with no account of whether that current is in step with the voltage.

The relationship between the two is the power factorpower factor: A number from 0 to 1 that says how much of the apparent power a load actually turns into work: watts equal volt-amperes times the power factor., a number from 0 to 1: watts equal volt-amperes times the power factor. A resistive load (an electric heater, an incandescent lamp) has a power factor near 1 and its watts and VA are almost the same. A load with a motor or an older power supply pulls current slightly ahead of or behind the voltage, so its power factor is 0.5 to 0.7 and its VA is well above its watts. A basic UPS feeding small single-phase devices is typically rated at a power factor of 0.6, which is why a label of 650 VA sits beside a label of 390 W: 650 × 0.6 = 390.

# Size a UPS for a small office of two desktops, one Wi-Fi router, one fibre ONT and one monitor. Watts come from each
# device's label at normal use; VA follows from an apparent power factor the lesson derives (watts / power factor). Then
# the load is checked against two candidate UPS units, and a runtime estimate is drawn from the UPS's battery energy.
# All inputs are label values picked for a lesson, not a specific product.

devices = [
    # (name, watts under normal use)
    ("desktop A on a design job",   220),
    ("desktop B at the browser",     95),
    ("27-inch monitor",              28),
    ("Wi-Fi router",                  8),
    ("fibre ONT",                     6),
]
power_factor = 0.6   # a lesson value for small single-phase devices behind a basic UPS inverter

print(f"{'device':<26}{'watts':>8}")
for name, watts in devices:
    print(f"{name:<26}{watts:>8}")
load_w = sum(w for _, w in devices)
load_va = load_w / power_factor
print(f"{'total':<26}{load_w:>8}  <- the load in watts")
print(f"load in VA at PF={power_factor}: {load_va:.0f}  <- what the UPS sees as apparent power")
print()

# Two candidate UPS units: a basic home unit and an office-class one.
ups_units = [
    # (name, rated VA, rated W, battery nominal voltage, battery amp-hours)
    ("A: 650 VA / 390 W basic UPS",     650,  390, 12.0,  7.0),
    ("B: 1000 VA / 600 W office UPS",  1000,  600, 12.0,  9.0),
]
for name, rated_va, rated_w, v_batt, ah in ups_units:
    fits_va = load_va <= rated_va
    fits_w  = load_w  <= rated_w
    verdict = "fits" if fits_va and fits_w else "does NOT fit"
    battery_wh = v_batt * ah
    print(f"{name}")
    print(f"  VA limit {rated_va:>5}, load {load_va:>5.0f} VA -> {'ok' if fits_va else 'over by ' + f'{load_va - rated_va:.0f}'}")
    print(f"  W  limit {rated_w:>5}, load {load_w:>5} W  -> {'ok' if fits_w  else 'over by ' + f'{load_w  - rated_w:.0f}'}")
    print(f"  verdict: {verdict}")
    if fits_va and fits_w:
        # A rough runtime: battery energy divided by the load in watts, with an 85 % inverter efficiency.
        inverter = 0.85
        usable_wh = battery_wh * inverter
        minutes = (usable_wh / load_w) * 60
        print(f"  battery {battery_wh:.0f} Wh x 85% inverter = {usable_wh:.1f} Wh usable")
        print(f"  rough runtime at {load_w} W: {minutes:.1f} minutes (optimistic; see the next example)")
    print()

device                       watts
desktop A on a design job      220
desktop B at the browser        95
27-inch monitor                 28
Wi-Fi router                     8
fibre ONT                        6
total                          357  <- the load in watts
load in VA at PF=0.6: 595  <- what the UPS sees as apparent power

A: 650 VA / 390 W basic UPS
  VA limit   650, load   595 VA -> ok
  W  limit   390, load   357 W  -> ok
  verdict: fits
  battery 84 Wh x 85% inverter = 71.4 Wh usable
  rough runtime at 357 W: 12.0 minutes (optimistic; see the next example)

B: 1000 VA / 600 W office UPS
  VA limit  1000, load   595 VA -> ok
  W  limit   600, load   357 W  -> ok
  verdict: fits
  battery 108 Wh x 85% inverter = 91.8 Wh usable
  rough runtime at 357 W: 15.4 minutes (optimistic; see the next example)

The office draws 357 W when desktop A is on a design job and desktop B is browsing: watts and VA, 357 and 595. Both the 650 VA / 390 W unit and the 1,000 VA / 600 W unit sit above each limit, so either fits on paper. The smaller unit’s VA headroom is 55 (595 against 650) and its watts headroom is 33 (357 against 390), so a tenth device of about 25 W is the last one it will accept. The MySmartCoPilot watts-to-amps calculator turns the same numbers in and out of volts, amps and watts for a quick second check.

Both the examples’ numbers and the sizing flow pick the same unit from the same labels, so the arithmetic matches whether a learner reads the program or the figure. The office could in principle place the load on either unit; the 1,000 VA / 600 W box leaves more room for a desktop that the owner swaps for a workstation with a graphics card, which pulls another 200 W.

The honest runtime: battery age, inverter loss and the Peukert effect

Nameplate runtime is the UPS’s battery energy divided by the load. The battery energy is its voltage times its amp-hour rating: a sealed 12 V, 7 Ah battery inside a 650 VA unit holds 84 watt-hours of nameplate energy, and divided by a 357 W load that gives 14.1 minutes of raw autonomy. The real figure is well below that for three reasons the help desk cannot wish away.

The first is inverter loss. The inverter and the transfer stage of a basic UPS give back about 85 % of the battery’s energy as alternating current; the other 15 % becomes heat in the box. The second is battery age. A sealed lead-acid battery kept at Indian room temperatures loses about 20 % of its usable charge after three years and about 40 % after five, even when it is never used, because the internal plates sulfate as the chemistry settles. The third is the Peukert effect: a lead-acid battery delivers less of its rated capacity at a high discharge rate than at a low one, with a Peukert exponent of about 1.2 to 1.3 for a typical unit, which costs another 40 % at the kinds of currents a desktop load pulls.

# The rough runtime from ups_check.py divided a UPS battery's nameplate energy by the load. Three things pull the real
# runtime below that: the inverter loses some energy as heat; a battery stops holding its full charge after a few years;
# and a lead-acid battery gives less energy when it is drained quickly, the Peukert effect. The program walks each one
# across the load the previous example found, and across a lighter load for an ONT and a router alone.

def runtime_min(battery_wh, load_w, inverter=0.85, age=1.0, peukert=1.0):
    """Minutes a UPS lasts: usable energy over the load. Each factor is between 0 and 1 (except peukert, see note)."""
    # Peukert: at a high discharge rate, a lead-acid battery delivers less of its labelled energy. For a 7 Ah battery
    # a load that empties it in under 15 minutes typically gives about 60 % of the nameplate at a Peukert exponent of
    # about 1.3; a slower discharge gives about 90 %. The factor is picked for the lesson, not fitted to one model.
    usable_wh = battery_wh * inverter * age * peukert
    return (usable_wh / load_w) * 60

# The small office of ups_check.py: 357 W behind a basic UPS with a 12 V / 7 Ah battery (84 Wh nameplate).
battery_wh = 12 * 7
load_desk = 357
load_light = 14   # the Wi-Fi router (8 W) and the fibre ONT (6 W), the two devices that keep the office online

print(f"{'case':<34}{'inv':>6}{'age':>6}{'Pk':>6}{'minutes':>10}")
cases = [
    ("nameplate: Wh over watts",         1.00, 1.00, 1.00),
    ("+ 85 % inverter efficiency",       0.85, 1.00, 1.00),
    ("+ 3-year battery, 80 % left",      0.85, 0.80, 1.00),
    ("+ Peukert at a fast discharge",    0.85, 0.80, 0.60),
    ("5-year battery (60 % left)",       0.85, 0.60, 0.60),
]
for name, inv, age, pk in cases:
    minutes = runtime_min(battery_wh, load_desk, inv, age, pk)
    print(f"{name:<34}{inv:>6.2f}{age:>6.2f}{pk:>6.2f}{minutes:>8.1f} min")

print()
print(f"the same five cases, but with the two desktops and the monitor switched off, keeping only the router and ONT ({load_light} W):")
for name, inv, age, pk in cases:
    minutes = runtime_min(battery_wh, load_light, inv, age, pk)
    print(f"{name:<34}{inv:>6.2f}{age:>6.2f}{pk:>6.2f}{minutes:>8.1f} min")

print()
print("so a 3-year-old 650 VA UPS at 357 W gives only about 5 minutes, barely enough to save work; the same UPS")
print("keeps a router and ONT online for about 2 hours. A plan that leaves the office with the network is often more")
print("useful than one that keeps the desktops awake for 4 or 5 minutes extra.")

case                                 inv   age    Pk   minutes
nameplate: Wh over watts            1.00  1.00  1.00    14.1 min
+ 85 % inverter efficiency          0.85  1.00  1.00    12.0 min
+ 3-year battery, 80 % left         0.85  0.80  1.00     9.6 min
+ Peukert at a fast discharge       0.85  0.80  0.60     5.8 min
5-year battery (60 % left)          0.85  0.60  0.60     4.3 min

the same five cases, but with the two desktops and the monitor switched off, keeping only the router and ONT (14 W):
nameplate: Wh over watts            1.00  1.00  1.00   360.0 min
+ 85 % inverter efficiency          0.85  1.00  1.00   306.0 min
+ 3-year battery, 80 % left         0.85  0.80  1.00   244.8 min
+ Peukert at a fast discharge       0.85  0.80  0.60   146.9 min
5-year battery (60 % left)          0.85  0.60  0.60   110.2 min

so a 3-year-old 650 VA UPS at 357 W gives only about 5 minutes, barely enough to save work; the same UPS
keeps a router and ONT online for about 2 hours. A plan that leaves the office with the network is often more
useful than one that keeps the desktops awake for 4 or 5 minutes extra.

The chain is honest and short: 14.1 min on the nameplate becomes 12.0 min after the inverter, 9.6 min after a 3-year-old battery, and 5.8 min once the Peukert loss is counted at that discharge rate. A 5-year-old unit on the same load gives 4.3 minutes. The second table on the run shows what happens when the two desktops and the monitor are shut down and only the Wi-Fi router and the ONT stay on: 14 W instead of 357 W turns the same UPS into a 2-hour network keeper, which is often more useful on a 90-minute cut than keeping the desktops awake for four extra minutes. The battery life calculator does the same chain for any battery, load and derating.

Surge protector or UPS, and when either is enough

A surge protectorsurge protector: A strip or brick that clamps mains voltage spikes with a varistor, absorbing joules until the rating is spent. It has no battery and does not help a cut. is a strip or a brick that clamps mains voltage spikes through a metal-oxide varistor, which absorbs the spike as heat and dies a little each time. The strip’s specification is the joules it is rated to absorb (300 to 2,000 for consumer models) and whether an indicator light reports when the varistor has used its budget up. A spike that costs the varistor 200 J of its 600 J rating leaves 400 J for the next ones, and once the rating is spent the strip still passes mains to the socket with no protection at all: the light is the only sign.

A UPS carries the surge protector’s job in its input stage and adds the battery. On a brownout or a cut it switches the load to the inverter; on a spike it clamps the spike before it reaches the output. So the question is never whether to pick a surge protector or a UPS; it is whether a cut matters here as well as a spike. A printer, a scanner and most set-top boxes shrug off a 5-minute cut and come back on their own, so a surge protector is enough; a desktop, a server and a Wi-Fi router under VoIP need a UPS as well because losing power mid-write risks a corrupted file system or a dropped call.

In India the mains voltage sits at 220 to 240 V and nominally 50 Hz, with cuts and brownouts common enough that a UPS is a desk accessory and not a server-room feature. Size a desk UPS for a safe shutdown of three to five minutes rather than all-day work; for all-day work the budget is an inverter and a battery bank, not a UPS, and the question moves out of this lesson into generator and electrical scope.

Lithium-ion batteries: swelling, replacement and legal disposal

Laptops, phones and the growing number of small UPS units with lithium-ion packs share one failure mode no help desk should ever work through: a lithium-ion celllithium-ion cell: A rechargeable cell used in laptops, phones and newer UPS units. A puffed or distorted cell is a safety stop-work sign and goes to an authorised recycler. that has puffed up and pressed the case open. A swollen cell is a cell whose electrolyte has broken down and released gas, usually from heat, overcharging, a manufacturing defect or old age. Pressing it, puncturing it or trying to force it back into shape risks a fire that burns at over 1,000 degrees and that water will not put out.

Battery health is a quieter signal most of the time. macOS reports the Maximum Capacity of a laptop’s battery under Battery → Battery Health (85 % of nameplate at two years is a usual figure); Windows writes a full report through powercfg /batteryreport (Microsoft’s own documentation describes the HTML file it emits, which lists design capacity against full-charge capacity). When Full Charge Capacity drops below 80 % of the design value, the user’s day shortens, the fan runs harder and a battery service is on order.

A puffed cell has three warning signs the user usually notices first: the trackpad or the keyboard rises a little, the laptop no longer sits flat on the desk, or the back cover begins to separate from the frame. One is enough to stop work. A phone’s screen can lift at its edges for the same reason; an older power bank’s case can split along its seam. The thickness of the swelling says nothing about how close the cell is to failing, so the rule is the same for a gentle bulge and a dramatic one: do not use the device until it is in a recycler’s hands. Replacing the battery alone restores the device for the user in most cases; the laptop goes to its maker’s service centre or an authorised repair partner, with the swollen pack isolated for the trip.

Practise: a load, a UPS and whether the two fit

Write the function the help desk reaches for before buying a UPS. It takes a list of devices, each with its watts, and a UPS’s VA and W limits, and reports whether the load fits on both. Keep both flags visible, because a load over on VA alone is a common pattern a single boolean would hide.

{
    "load_w": <int>,     # sum of the devices' watts, rounded to the nearest whole watt
    "load_va": <int>,    # load_w divided by the power factor, rounded to the nearest VA
    "fits_w": <bool>,    # load_w <= watts
    "fits_va": <bool>,   # load_va <= va
    "fits": <bool>,      # both limits hold
}

def ups_load_check(devices, va, watts, power_factor=0.6):
    """Return load watts and VA, and whether a UPS of (va, watts) fits them at the given power factor."""
    return {"load_w": 0, "load_va": 0, "fits_w": False, "fits_va": False, "fits": False}

from ups_load_check import ups_load_check


def test_empty_load_fits_anything():
    """an empty office load is a passing check against any UPS"""
    result = ups_load_check([], va=400, watts=240)
    assert result == {"load_w": 0, "load_va": 0, "fits_w": True, "fits_va": True, "fits": True}


def test_small_office_fits_the_basic_ups():
    """357 W of office kit at power factor 0.6 fits a 650 VA / 390 W unit (595 < 650, 357 < 390)"""
    load = [("desktop A", 220), ("desktop B", 95), ("monitor", 28), ("router", 8), ("ONT", 6)]
    result = ups_load_check(load, va=650, watts=390)
    assert result["load_w"] == 357
    assert result["load_va"] == 595
    assert result["fits_w"] is True
    assert result["fits_va"] is True
    assert result["fits"] is True


def test_over_only_watts():
    """a load inside the VA box but over on watts fails as a whole"""
    load = [("space heater", 1500)]
    result = ups_load_check(load, va=3000, watts=1000, power_factor=0.9)
    assert result["load_w"] == 1500
    assert result["load_va"] == 1667
    assert result["fits_w"] is False
    assert result["fits_va"] is True
    assert result["fits"] is False


def test_over_only_va():
    """a load inside watts but over on VA fails as a whole (low power factor)"""
    load = [("laser printer idle", 25), ("old pump motor", 150)]
    result = ups_load_check(load, va=200, watts=250, power_factor=0.5)
    assert result["load_w"] == 175
    assert result["load_va"] == 350
    assert result["fits_w"] is True
    assert result["fits_va"] is False
    assert result["fits"] is False


def test_power_factor_defaults_to_zero_point_six():
    """the default power factor is 0.6, so 300 W becomes 500 VA"""
    assert ups_load_check([("one", 300)], va=1000, watts=1000)["load_va"] == 500


def test_rounds_to_the_nearest_whole_number():
    """non-integer watts round to the nearest VA, not a floor"""
    assert ups_load_check([("fan", 11.5)], va=100, watts=100, power_factor=0.9)["load_va"] == 13


def test_rejects_a_negative_watt_figure():
    """a device cannot draw negative power"""
    try:
        ups_load_check([("mystery", -10)], va=100, watts=100)
    except ValueError:
        return
    raise AssertionError("ups_load_check with -10 W should raise ValueError")


def test_rejects_an_impossible_power_factor():
    """a power factor must sit in (0, 1]"""
    for bad in (0, -0.5, 1.1):
        try:
            ups_load_check([("one", 100)], va=200, watts=200, power_factor=bad)
        except ValueError:
            continue
        raise AssertionError(f"ups_load_check with power_factor={bad} should raise ValueError")

Interview questions

Warm-up (fresher): a user says a 1,000 VA UPS fits their 600 W PC because 1,000 is more than 600. What do you check before you agree?

The two numbers are measured in different units and both have to hold. Check the UPS’s watts rating as well as its VA rating; most 1,000 VA units are 600 W, so a 600 W desktop at a power factor of 0.9 (a modern PSU with active PFC) draws 600 W and about 667 VA, which fits both. The same desktop at a power factor of 0.6 (an older or very basic unit) would draw 1,000 VA for the same 600 W, which still fits VA, but any extra load would trip the UPS. Also check that 600 W is the real draw and not the PSU’s label: a 600 W PSU usually sees 150 to 250 W in office work, so the real load is well below the UPS’s W limit and the headroom goes to runtime instead.

Two harder cases follow. Decide a first step on each from what you have read, then open the question to see how far your plan matches the model:

Key takeaways

• A desktop PSU splits mains into +12 V, +5 V and +3.3 V rails and stays sealed; its primary capacitors hold mains voltage for several minutes after it is unplugged, so a failed unit is replaced, not opened.
• Standby, line-interactive and double conversion UPS designs trade cost for a shorter transfer time and cleaner output: standby is the cheapest; line-interactive handles brownouts without the battery; double conversion gives no gap at all.
• A UPS has two limits, VA and watts, and a load fits only when its watts and its VA sit below both at the same time; watts equal VA times the power factor the inverter sees.
• Honest UPS runtime is the battery’s energy divided by the load, then cut by about 15 % for the inverter, about 20 % for a 3-year-old battery and about 40 % for the Peukert effect: a 650 VA unit at 357 W lasts 5 minutes, not 14.
• A swollen lithium-ion battery is a stop-work sign: shut the device down, isolate it in a non-flammable container, never prise it open, and route it to a recycler registered under the Battery Waste Management Rules, 2022.