The Repair LibraryRead · Learn · Master

PoP Separation and Rework

The chapter closes with the mechanics its theory section made survivable: taking a stack apart one level at a time, and rebuilding it in the order the geometry demands. The section's first law is inherited and absolute — no stack sees heat without its dossier. The theory section's deliverable — census, geometry sketch, fault partition, melt-order brief — is this section's authorization, opened and verified cold exactly as the reflow section opened its placement record, because a stack surgery improvised at temperature is two heat lifetimes spent on a guess. Then the surgeries, lighter first. Top-only separation lives in the melt window: top-biased heat walks the interface ring to liquidus while the board field stays solid, the memory lifts zero-force on the pen, and the processor never moves — the surgery of choice whenever the partition points up, and the reason the window was mapped before the station warmed. The full-stack removal is the heavier operation: the double-molten moment entered deliberately, held briefly, exited with a single lift of the whole stack — and the separation finished off-board, where the lifted stack splits on the bench under top-biased heat with the board no longer at risk. Between the surgeries sits the dressing craft the stack doubles: the processor's top-face lands wicked and planed while the package sits seated — low-mass tools, the board field kept far from liquidus — and the interface rebuilt with the volume's own placement and reflow law. The rebuild runs level by level, bottom up: the processor installed and verified as the standard BGA operation it is, then the memory flown onto the interface with a top-biased profile that respects the board field below — each level verified before the next builds on it, claims bounded, power last. Two fields built in order, each proven before the next — that is the stack rebuilt, and the chapter closed.

ProfessionalMedium Risk23 min read

What You Will Learn

  • You will learn the dossier gate — the theory section's deliverable opened as authorization before any stack heat.
  • You will learn top-only separation — the window lift that takes the memory while the processor never moves.
  • You will learn the full-stack removal — the double-molten moment entered deliberately, and the off-board split that follows.
  • You will learn the interface dressing — top-face lands planed on a seated package with low-mass tools.
  • You will learn the level-by-level rebuild — bottom up, each field verified before the next builds on it.

What You Will Be Able To Do

  • You will be able to gate a stack surgery on its dossier and refuse heat until the brief matches the station.
  • You will be able to execute a top-only separation inside the melt window.
  • You will be able to run a full-stack removal through its double-molten moment and split the stack off-board.
  • You will be able to dress interface lands on a seated processor without disturbing the board field.
  • You will be able to rebuild a stack level by level with per-level verification and bounded claims.

Required Tools

  • The rework station with top-biased control — the melt window only exists for heat that arrives from above
  • The stack dossier from the theory section — census, sketch, partition, melt-order brief; no heat without it
  • The vacuum pen and fine tweezers — the window lift is zero-force, and the interface dressing is low-mass work
  • The fine iron, wick, and flux — top-face land dressing on a seated processor demands the smallest tools the bench owns
  • The meter and the partition map — each rebuilt level is verified before the next builds on it

When NOT to Attempt This

Do not attempt this section if any of the following apply to you:

  • You are not experienced with the specific repair type described here.
  • You do not have professional-grade equipment for this procedure.
  • The device has sentimental or high monetary value and you cannot afford a mistake.
  • You have not successfully completed this repair on a sacrificial device first.

Section Overview

The chapter's mechanics arrive where its theory pointed: the stack comes apart one level at a time, and rebuilds in the order the geometry demands (pop-package-on-package-theory). The stack dossier is the gate. Census, sketch, partition, melt-order brief — opened cold, matched to the station, before any heat (bga-reflow-and-verification). The window lift is the lighter surgery. Top-biased heat, interface at liquidus, board field solid — the memory rises zero-force and the processor never moves (bga-removal-with-hot-air). The full-stack removal is the heavier one. The double-molten moment entered deliberately, held briefly, exited with one lift — and the stack splits off-board, where the board is no longer at risk. The dressing serves both. Top-face lands wicked and planed on a seated processor — low-mass tools, the board field kept far from liquidus. And the level-by-level rebuild closes it. Processor first as the standard install it is, memory flown top-biased onto the verified interface, each level proven before the next (bga-placement-and-alignment). Gate, window, moment, dressing, levels — the separation entire, and the chapter closed.

Why This Matters

Stack surgery is where the volume's costliest silicon meets its highest-risk minutes, and the discipline is what makes the meeting survivable (pop-package-on-package-theory). This matters because the dossier is the difference between surgery and gambling: the window, the partition, and the abort rules were all derivable cold — the bench that heats without them is deriving physics at temperature with two packages on the table (bga-reflow-and-verification). This matters because the window rewards the bench that mapped it: top-only separation is the stack's best economics — one field risked, one heat lifetime spent, the processor never afloat — and it exists only inside a window somebody measured (bga-removal-with-hot-air). It matters because the double-molten moment does not forgive drift: two liquid fields under one stack is the volume's least stable configuration, entered deliberately and exited fast, never wandered into. It matters because the interface dressing is heat surgery on a live patient: the processor stays seated while its top lands are planed — the lowest-mass work in the volume, over the board field that must never re-melt (bga-placement-and-alignment). And it matters because the rebuild order is the geometry's own law: bottom up, each level verified — a fault discovered under a rebuilt level costs both levels, which is why no level builds on an unproven one. Plan cold, lift in the window, rebuild in order — the stack's law entire.

Required Prerequisites

Before starting this section, you should have completed:

  • PoP — Package-on-Package Theory — the geometry, the mismatch, and the melt order this section assumes cold: the stack dossier built there is this section's entry ticket.
  • BGA Reflow and Verification — the authorization discipline, the flight fidelity, and the bounded-claim verification this section applies twice per stack.
  • Tacky flux and liquid flux — the interface rebuild's chemistry and the dressing's helper; thin-even judgment throughout.
  • Wick in the narrowest widths — top-face land dressing is the volume's lowest-mass wick work; wide braid drags heat the seated processor cannot spare.
  • Isopropyl alcohol and lint-free wipes — interface lands read and rebuild clean; residue on top-face lands is a seat error waiting.
  • Kapton tape and shield stock — the stack's neighborhood shields like any removal, and the top-biased flight concentrates spill risk above.
  • Sacrificial donor phone boards with confirmed stacks — the practice patients: the census from the theory section marks which donors carry stacks worth drilling on.
  • A donor stack already separated, if available — the interface lands and mold wells seen bare calibrate the dressing exercise before the first live separation.
  • The bench preheater or hot plate — the off-board split runs on it, and the rebuild's board-side support leans on it.

Real-World Applications

Stack separation is the daily craft of data recovery and board-level repair at their most demanding. A data-recovery lab reaching a phone's storage path runs the window lift exactly as taught — on a stack whose top package carries the storage, and whose dossier confirmed an unbonded interface: dossier opened, top-biased flight, the storage package off zero-force in the window, the board and its processor preserved as the working evidence platform (pop-package-on-package-theory). A repair house replacing failed memory on a tablet's stack executes the chapter's full arc: top-only separation, interface dressed both sides, replacement memory flown on level by level, each field verified before the next claim is written (bga-placement-and-alignment). A salvage bench harvesting a known-good processor from a shattered board takes the heavier road: full-stack removal through the planned double-molten moment, the off-board split on the preheater, and the harvested processor dressed for its transplant (bga-removal-with-hot-air). And a bench running its first top-only under supervision learns why the theory section came first: the window is real, the brief predicted it, and the lift lands inside numbers somebody wrote down cold (bga-reflow-and-verification). The confusions this prevents: a stack heated without its brief, a window entered late and closed into a surprise, an interface dressed with removal-scale tools over a live board field, and a rebuild that buried an unverified level under a verified one.

Common Challenges

  • The window is narrow and moves. Package classes, shield mass, and station bias all shift the gap between the two liquidus moments — the brief maps it for this stack on this station, and the flight watches the tells rather than trusting the clock (pop-package-on-package-theory).
  • The seated processor limits the dressing. Its board field holds a deliberate, wide standing margin under the preheater's balance — but the package is thin, and every iron contact spends that margin locally and invisibly — low-mass tools, brief contacts, and the preheater carrying the base load are what make top-face dressing survivable (bga-removal-with-hot-air).
  • Replacement memory is its own supply problem. The part must match the interface's pattern and the processor's pairing — the dossier's census and the donor market answer it, and the job is quoted after the part is found, not before (bga-reflow-and-verification).
  • The rebuild doubles every discipline. Two placements, two flights, two verifications — the level-by-level order keeps the doubling honest, and the bench that shortcuts a level's verification builds on the volume's most expensive assumption (bga-placement-and-alignment).

Safety Notes

Risk Level: Medium. Live heat over the board's most expensive silicon, twice over — the full rework law, plus the stack's own lines.

  • Fume extraction from preheat — two flights per rebuild means twice the flux load; the extractor runs from the first stage of each.
  • The dossier gate before every heated step — separation, dressing, and each rebuild level all check the brief first.
  • The bond question is a safety check — an underfilled or corner-glued interface cannot window-lift at any survivable temperature, and the pry that answers the refusal takes the processor's top lands with it; the dossier answers the question cold.
  • Deliberate entry only — the double-molten moment is scheduled, held briefly, and exited with the lift; drifting into it is the abort criterion.
  • Split off-board — the bench split risks the stack alone; an on-board split risks the patient.
  • Power last, current-limited, after the last level's ladder — the rebuilt stack's first power crosses two fields' worth of claims.

Professional Tips Before Starting

  • Verify the dossier against the station, not just the stack. The theory section's brief was written for a heating geometry — a top-biased brief flown on a bottom-preheat-dominant station has the window in the wrong place, and the check costs a minute cold (pop-package-on-package-theory).
  • Rehearse the lift dry. Pen angle, approach, the lift's vector — practiced cold on the fixtured board — the window is seconds wide, and the hands that rehearsed spend none of them deciding (bga-removal-with-hot-air).
  • Stage both flights before the first. The rebuild's second flight is designed before the first flies — a rebuilt processor waiting on an undesigned memory flight is a patient parked at half-surgery (bga-reflow-and-verification).
  • Source the memory before the separation. The replacement part's pattern and pairing come from the dossier's census — separating first and sourcing second strands a dressed interface in the open air (bga-placement-and-alignment).
  • Log each level as its own case. The stack's file carries two placements, two flights, two verifications — level-tagged entries keep the claims sorted when the warranty question arrives.

The Separation — Gate, Window, Moment, Dressing, Levels

Recap and Frame

The theory section built the stack's geometry, its mismatch, and its melt order — this section spends them (pop-package-on-package-theory). The removal law arrives twice-trained. Shield map, preheat, molten-field check, zero-force lift — the BGA discipline, now aimed at a package that is itself standing on a package (bga-removal-with-hot-air). The install law arrives proven. Authorization, flight fidelity, settle read, bounded ladder — the reflow section's discipline, about to run twice per stack (bga-reflow-and-verification). And the placement law arrives doubled. Witness, straight descent, seat check — once for the processor on its board, once for the memory on its interface (bga-placement-and-alignment). Theory spent, laws doubled — the frame set, and the dossier decides who proceeds.

The Gate and the Window — Top-Only Separation

No stack sees heat without its dossier, and the gate is checked cold: census current, sketch in hand, partition written, melt-order brief matched to the station actually in use — and the bond question answered: whether the board field and the interface carry underfill or corner glue, because the foundation section taught the glue as the standing condition on exactly these boards, and a bonded interface takes the window lift off the table entirely (pop-package-on-package-theory). The fixture and shields come first. The board fixtured and preheated, the neighborhood shielded, the pen staged at the rehearsed angle — the removal law's opening, unchanged (bga-removal-with-hot-air). The flight is top-biased by design. Heat from above walks the interface ring toward liquidus while the board field, buried under the stack's bulk and defended by the preheat balance, stays solid — the gap between the two liquidus moments opening exactly where the brief mapped it. The window announces itself. The interface's tells — flux activity at the seam, the ring's solder brightening, the brief's timing corridor — read together; the clock alone is nobody's authorization (bga-reflow-and-verification). The lift is zero-force inside the window. The pen takes the memory straight up — no twist, no pry, the interface fully molten and the board field still holding — and the processor never moves. Zero-force assumes an unbonded interface. That assumption is the dossier's to verify, cold: a glued interface will not release at any temperature the stack survives, the refusal reads exactly like a missed window, and the surgery reroutes — adhesive-aware plan, full-stack removal, or an honest no-go — before the station ever warms. Late is the abort. A window entered late closes into the double-molten moment unplanned: the flight aborts per the brief — controlled cool, stack intact, diagnosis cold — never a hurried lift over two liquid fields (bga-placement-and-alignment). Gate, fixture, bias, tells, lift, abort — the window entire. Top-only separation is the stack's best surgery because the theory section priced it: one field risked, one lifetime spent, the processor never afloat.

The Moment and the Split — Full-Stack Removal

When the partition points down, or both fields are already spent, the heavier surgery runs: the whole stack off in one lift (pop-package-on-package-theory). The double-molten moment is scheduled, not discovered. The flight carries both fields to liquidus in the brief's order — interface first, board field following — and the moment both are liquid is entered deliberately: the least stable seconds in the volume, held only as long as the lift needs (bga-removal-with-hot-air). The lift takes the stack whole. One straight pull on the pen at the board field's full liquidus — the interface travels as cargo, molten but confined between its packages, with heavier stacks lifted by the bottom package's edge so the molten ring never carries the load — and the board keeps every pad where it belongs. The split moves off-board. The lifted stack separates on the bench: preheater base, top-biased heat, the interface walked back to liquidus with only the stack at stake — the board is out of the equation, which is the whole point of splitting second (bga-reflow-and-verification). The dressing follows the split. The processor's top-face lands wicked and planed with the narrowest braid and the briefest contacts — low-mass work over a package that must survive its own dressing — and its board-side field dressed flat for the transplant or the rebuild (bga-placement-and-alignment). Schedule, lift, split, dress — the moment entire. The full-stack removal is the heavier road because it spends both lifetimes — the envelope math chose it before the station warmed, or it should not be running.

The Rebuild — Level by Level, Bottom Up

The stack rebuilds in the order the geometry demands: bottom up, each level proven before the next builds on it (pop-package-on-package-theory). The processor installs as the standard operation it is. Site dressed, placement under the witness and seat check, the profile card flown with fidelity, the ladder climbed and claims bounded — the chapter five arc, run whole, because the bottom level is exactly that job (bga-reflow-and-verification). The bottom level verifies before the top exists. Fanout map, reachable nets, X-ray where owned — a fault found now costs one level; found later it costs both, plus the memory riding above it. The interface builds second. The processor's top lands fluxed thin and even, the memory placed under its own witness — orientation matters at the interface exactly as it does at the board — and the seat checked loose (bga-placement-and-alignment). The second flight is top-biased by law. The memory's install profile concentrates its heat above: the interface reaches liquidus and settles while the board field below — already verified, already trusted — stays inside its solid margin; re-melting a proven level is the rebuild's one unforgivable economy (bga-removal-with-hot-air). The top level verifies on the partition. Memory-bus nets through the interface, the warm-cycle check against the mismatch's signature, claims bounded per level in the case file. Then power, last, once. Current-limited, behind two levels' ladders — the rebuilt stack answers as one component only after both fields have answered separately. Bottom, prove, interface, bias, prove, power — the rebuild entire. Two fields built in order, each proven before the next trusted it — that is a stack rebuilt, and that is the chapter.

Common Mistakes

  • Heating without the dossier. The window and the moment are exactly where improvisation destroys both packages — the gate is a safety rule wearing a checklist (pop-package-on-package-theory).
  • Trusting the clock over the tells. The brief's corridor is a prediction; the seam's flux activity and the ring's brightening are the evidence — lifts run on tells confirmed inside the corridor, not on seconds elapsed (bga-reflow-and-verification).
  • Riding a late window. The lift that chases a closing window arrives over two liquid fields — late is the abort, and the abort is a controlled cool with the stack intact (bga-removal-with-hot-air).
  • Dressing the interface with removal-scale tools. Wide braid and big tips drag heat the seated processor cannot spare — top-face dressing is the volume's lowest-mass work, or it is board-field damage in progress.
  • Splitting on the board. An on-board split risks the patient to save a bench step — the stack separates on the preheater, where only the stack is at stake.
  • Building on an unverified level. The rebuilt processor that was never mapped carries the memory onto a guess — each level proves before the next, because a buried fault costs every level above it (bga-placement-and-alignment).

Troubleshooting Guidance

  • Window will not open — board field approaching liquidus first — the station's bias does not match the brief: abort per the brief, re-balance top heat against base preheat, and re-derive the corridor for the geometry actually in use — the theory section's station warning made real (pop-package-on-package-theory).
  • Memory resists the lift in the window — the interface is not fully molten, a mold-well corner still holds, or the interface is bonded — underfill or corner glue the dossier's bond check should have caught: no force — re-read the tells, extend inside the corridor if the brief allows, and abort to controlled cool if it does not; a pried interface takes the processor's top lands with it (bga-removal-with-hot-air).
  • Interface lands lift or smear during dressing — too much heat or too much drag on the volume's most delicate field: stop, photograph, and re-assess against the pad-repair envelope — a processor with damaged top lands may still transplant onto a board field job, but its stack days may be over (bga-placement-and-alignment).
  • Rebuilt bottom level fails its verification — the gate worked: the fault costs one level because the order was honored — dress, diagnose, and re-run the bottom before any memory flies; the rebuild's economics survive exactly because the memory was not aboard (bga-reflow-and-verification).

Verification & Testing Methods

Confirm your separation discipline before calling this section complete:

  • [ ] I gate every stack surgery on its stack dossier — census, sketch, partition, brief — verified cold against the station in use.
  • [ ] I can run a top-only separation: top-biased flight, tells confirmed in the corridor, the window lift zero-force with the processor never moving.
  • [ ] I can run a full-stack removal: the double-molten moment scheduled and brief, one whole-stack lift, the split off-board.
  • [ ] I can dress interface lands on a seated processor — lowest-mass tools, briefest contacts, the board field's margin respected.
  • [ ] I can run the level-by-level rebuild — bottom up, each level verified before the next, claims bounded per level, power last and once.

Then try the practice exercises below — separation and rebuild on sacrificial donors; scenarios differ from the quiz.

Practice Exercises

  1. Open the gate (6 minutes, cold). Assemble the stack dossier for your practice donor — the theory section's census, sketch, and partition, plus a melt-order brief re-verified against this bench's actual heating bias — and write the separation plan: top-only case, window corridor, tells, and the abort at each stage (pop-package-on-package-theory).
  2. Lift in the window (7 minutes, the gated donor). Fly the top-biased flight with the brief beside the log: read the seam's tells into the corridor, take the memory zero-force on the pen, and confirm the processor never moved — then dress both interface sides — the top lands on the still-seated processor with the narrowest braid on the bench (bga-removal-with-hot-air).
  3. Rebuild level by level (7 minutes, the dressed donor). Refit the memory — or a matched donor part — onto the interface: thin-even flux, witness and seat check at the interface, the top-biased install flight, and the level's own verification through the memory-bus nets before any claim is written (bga-placement-and-alignment).
  4. Run the heavier road (5 minutes, a second sacrificial donor). Execute a full-stack removal: the double-molten moment scheduled and held only for the lift, the stack off whole, and the off-board split on the preheater — with the honest log line on what the drill cost the donor and what it taught the hands (bga-reflow-and-verification).

These core steps — the gate, the window lift, the level-by-level rebuild, and the scheduled moment with its off-board split — are tested in the Chapter Quiz at the end of this chapter, where a score of 80% is required to continue.

Key Takeaways

  • The stack dossier is the gate — census, sketch, partition, and melt-order brief verified cold against the station in use, because the window and the moment are exactly where improvisation destroys both packages (pop-package-on-package-theory).
  • The window lift is the stack's best surgery — top-biased heat, tells confirmed in the corridor, the memory off zero-force while the processor never moves (bga-removal-with-hot-air).
  • The full-stack removal schedules its double-molten moment — entered deliberately, held for the lift, exited whole — and the split runs off-board where only the stack is at stake (bga-reflow-and-verification).
  • The interface dressing is the volume's lowest-mass heat work — narrowest braid, briefest contacts, the seated processor's board field kept inside its solid margin.
  • The level-by-level rebuild runs bottom up with per-level proof — the processor as the standard install it is, the memory flown top-biased onto a verified foundation, claims bounded per level, power last and once (bga-placement-and-alignment).

Skills Learned

After completing this section, you can:

  • Gate stack surgeries on a dossier verified against the actual bench.
  • Execute top-only separations inside a mapped melt window.
  • Run full-stack removals through a scheduled double-molten moment and split stacks off-board.
  • Dress interface lands on seated processors with low-mass technique.
  • Rebuild stacks level by level with per-level verification and bounded claims.

Glossary Additions

New terms introduced in this section:

  • stack dossier — the theory section's deliverable promoted to authorization: the stack's census, geometry sketch, fault partition, and melt-order brief, assembled cold and verified against the station actually in use before any stack sees heat. The dossier is a safety gate, not paperwork — the melt window and the double-molten moment are exactly where improvisation destroys both packages, and the dossier exists so neither is ever met unplanned. Every heated step re-checks it: the separation, the dressing, and each rebuild level open the file before the station warms.
  • window lift — the top-only separation's defining act: with top-biased heat holding the interface ring at liquidus while the board field stays solid, the memory package lifts zero-force on the vacuum pen inside the gap between the two liquidus moments — and the processor never moves. The window is confirmed by tells, not clocks: flux activity at the seam and the ring's brightening, read inside the brief's timing corridor. A window entered late closes into an unplanned double-molten moment, and late is therefore the abort — a controlled cool with the stack intact, never a hurried lift over two liquid fields.
  • level-by-level rebuild — the stack's reconstruction in the order the geometry demands: bottom up, each level proven before the next builds on it. The processor installs as the standard board-side operation it is — placement law, profile card, bounded ladder — and verifies before the top level exists; the memory then flies onto the interface under a top-biased profile that keeps the proven board field inside its solid margin, and verifies through the partition's memory-bus nets. Claims stay bounded per level, and power arrives last and once — because a fault buried under a rebuilt level costs every level above it.

Suggested Next Sections

Must read next:

  • Reflow Oven Profiling — Chapter 7 opens the volume's final arc: advanced reflow techniques, beginning with the reflow oven and the profiling discipline that scales the card from one package to a whole board.

Recommended:

  • BGA Removal with Hot Air — the removal law the stack doubles: shields, preheat, molten-field check, and the zero-force lift the window borrows.
  • BGA Placement and Alignment — the placement law the rebuild runs twice: witness, straight descent, and the seat check — once at the board, once at the interface.