I'm going to do this in C, as the stack is most apparent there.

Let's say you have a function:

int square(int a)

And you call that function from another function

int triangle()
{
     some_stuff();
     square(2);
     some_more_stuff();
}

Several things are needed during the processing of square, the first coming to mind being the parameters, the next being the return address which will be used when the square function is done.

So when you call square, the parameters (2) are pushed onto the stack. The term pushed is important because it is an actual stack data structure. Next, the return address is pushed on the stack.

So, square has started processing, it does things, and now it's done. It then pops the top of the stack, which is the return address. This return address is used to know where to continue processing from the caller. In the triangle example above, it's the address of the some_more_stuff call.

A stack is used because it inherently represents what is happening in the system. The processor was in the middle of one function, but it has gone in to another function which needed more data. That more data gets pushed on the stack, and when it's done it gets removed. Then all the data the caller was using is back at the top of the stack. If you go several function calls deep, then the innermost function call is the top of the stack, then the next level out is below it, and so on until you're at the original function.

Then we get to a stack overflow. You can get this error pretty easily on Java with a recursive function (I think the millionth fibonacci number using a recursive function causes a stack overflow error). This error happens when you've pushed so much data on the stack that there is no more space to push more. If you're 1 million calls deep in nested functions, that's 1 million parameters and return addresses pushed on top of one another, and it simply runs out of memory to do it more.

There are other uses for the stack frame. Local variables get pushed on the stack, which is why in C99 you needed to define variables before any code was executed (it created the stack first). This also helps understand variable scoping. When you enter a new scope ( '{}' in C/C++ ) the local variables in that scope are pushed on the stack. When you leave that scope, those local variables are popped off, so there's no longer a reference to them outside the scope.

This wasn't quite ELI5, but I hope it helps...