a handle
When you are assembling a model and several small parts are loose on the table, only one grouping is the right one to glue together next, the one that fits the instructions and leaves the rest still assemblable. In bottom-up parsing the handle is that correct next grouping: the exact substring you should reduce at this step, and the rule you should reduce it by, so that you stay on the path to a valid parse.
More precisely, during bottom-up parsing the contents of the stack plus the unread input form a sentential form, a string derivable from the start symbol. A handle is a substring that matches the right-hand side of some production A -> alpha, sitting at the position where reducing it (replacing alpha by A) undoes one step of a rightmost derivation. The point is that not every match is a handle. The stack might contain symbols that happen to match a rule's right-hand side, yet reducing there would be a mistake that derails the parse; the handle is the one match that is both correct in content and correct in position. Finding the handle is exactly the shift-or-reduce decision a shift-reduce parser must make at every step.
The whole machinery of LR parsing exists to identify handles automatically. The LR state machine, built from the grammar, tracks enough context that, given the current state and the next look-ahead token, it knows whether the top of the stack is a handle ready to reduce or whether it must shift more input first. When the grammar makes this ambiguous, a handle could be reduced two ways, or it is unclear whether to shift or reduce, the result is a reduce-reduce or shift-reduce conflict.
Parsing num + num with E -> E + E | num, after reducing the first num the stack-and-input read E + num. The handle is the lone num at the right (reduce by E -> num), not E + num yet, because reducing too early would strand the parse. Only after that does E + E become the handle for E -> E + E.
A handle is the right substring AND right position to reduce next, not just any rule match.
A substring matching a rule's right-hand side is not automatically a handle: position matters. Reducing a non-handle match is a wrong move that breaks the parse, which is why finding handles needs the LR state machine, not just pattern matching.