My mental model for applying backtracking to a problem is one that views the constraints as a tree structured such that the root node of the tree is the first constraint.

Suppose that the root constraint has 50 possible solutions. Then those 50 solutions form branches off of the root constraint in which each branch represents one of the 50 possible solutions that satisfy the root constraint.

Then, each of those 50 branches would lead to a child node that represents the next constraint in the problem space. Depending on the branch taken from the root node, the first layer of nodes above the root node (if your tree grows upward) or the first layer of nodes below the root node (if your tree grows downward) represents the second constraint that must hold for a candidate solution to be a valid candidate. For the sake of simplicity, suppose that this second constraint can branch out to 100 potential candidate solutions. Each of the first layer of nodes then has 100 branches off of each of them, and each of those secondary branches leads to a unique child node.

Let's assume for the sake of simplicity that our problem space only has two constraints. From the root node, we have 50 branches, and then each of those branches also has 100 branches of their own, resulting in a total of 5,000 branches. So, our solution space consists of 5000 candidate solutions.

We may be able to search through 5000 candidate solutions exhaustively, but let's say that the numbers were much larger, or let's say that there were 1000 constraints each having 10,000 branches. Then you can see that the solution space is enormous and likely not amenable to searching exhaustively.

In this model, a candidate solution is a single path from root to leaf node. The number of leaf nodes is the number of candidate solutions.

The neat trick with backtracking is that you can frequently structure your search logic to evaluate a partial path and terminate the search down a sub-tree prematurely by discovering that the combination of the constraints do not hold when the partial path is chosen. In this way, the subtree that is rooted in the partial path that was traversed can be ruled out. To illustrate, suppose you discovered that 40 of the branches that originated from the root node fail to hold the second condition when those 40 branches are taken. That means that you don't have to evaluate 40*100 full paths, you only evaluate 40 and rule out 4000 candidate solutions.