Okay. Let's say we're rendering a bump map fed by an image texture in Eevee. I'll give a general run-down, but I may simplify some details. You'd be best off just reading a bump map implementation in some shader code (OGL or HLSL). That will tell you exactly what's happening, and it's a lot more accessible than you might think.
The bump node samples the image texture three times. First, at the UV of the sample being evaluated; then, a slight offset in the U axis; then, a slight offset in the V axis. The size of this offset depends on your zoom, texture resolution, and FoV; as you get closer, the offset gets smaller. (I think it actually samples at a screenspace offset of +1 pixel, and then calculates based off of that, but understanding it in terms of UV is probably more intuitive and amounts to the same thing.)
Each time we sample the image, we get a number. For each of our numbers, we subtract the bump node's midlevel, multiply by the bump's scale, and then multiply by our object's scale.
Then we calculate how big those UV offsets were in terms of world space-- we calculate the change in world space, divided by the change in UV. In Eevee, that's pretty easy, because our video cards are designed to work on four samples simultaneously, because calculating these deltas is really important for texture filtering, which is really really important.
Now we know, in two orthogonal axes, how much our height changes over a given world space distance, which lets us calculate a slope. For example, if our height changes 0.5 units in the direction of increasing U over 0.5 world space units, then we have a slope of 45 degrees. If it changes 0.25 units over the same world space, we have a slope of 30 degrees. (This is some basic trigonometry.) We take our base normal and rotate it, in the axis of changing V, by the slope we get by looking at the change in height in U, and we rotate it, in the axis of changing U, by the slope we get by looking at the change in height in V. Now we have a normal that's different than the one originally calculated from our mesh.
If you're okay with calculus, the tl;dr of all this is, we calculate the derivative of our height map and use that as our normal.
How we use this normal depends on the shader. Each shader does something different with a normal; a normal is a fundamental part of almost every shader, and their differences have a lot to do with what they do with their normals. So I won't go through all of them. But we can consider a diffuse BSDF with a 0.0 roughness, which is called a Lambertian diffuse. If we shine a light on this surface, what color do we get? It depends on the angle of the light, relative to the angle of the normal. The color we get is equal to the dot product of the surface normal and the reversed light vector (in whatever space, just so long as they're in the same space) times the color of the light, times the color of the surface, times the falloff fraction. The output color (before color management) is the sum of the contributions from each light.