That was a clickbaity title. :)
But seriously, people make a big deal out of ‘Dynamic Programming’, in the context of software engineering interviews. Also, the name sounds fancy but for most problems in such interviews, you can go from a naive recursive solution to an efficient solution, pretty easily.
Any problem that has the following properties can be solved with Dynamic Programming:
 Overlapping subproblems: When you might need the solution to the subproblems again.
 Optimal substructure: Optimizing the subproblems can help you get the optimal solution to the bigger problem.
You just have to do two things here:
 Check if you can apply the above criteria.
 Get a recursive solution to the problem.
That’s it.
Usually the second part is harder. After that, it is like clockwork, and the steps remain the same almost all the time.
Example
Assume, your recursive solution to say, compute the nth fibonacci number, is:
Step 1: Write this as a recursive solution first
1 2 3 4 5 6 7 

Now, this is an exponential time solution. Most of the inefficiency comes in because we recompute the solutions again and again. Draw the recursion tree as an exercise, and convince yourself that this is true.
Also, when you do this, you at least get a naive solution out of the way. The interviewer at least knows that you can solve the problem (perhaps, not efficiently, yet).
Step 2: Let’s just simply cache everything
Store every value ever computed.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 

Let us compute how many unique calls can we make to fibDP
?
 There is one parameter,
n
.  Hence,
n
unique values ofn
can be passed to fibDP.  Hence,
n
unique calls.
Now, realize two things:
 We would never compute the value of the function twice for the same value, ever.
 So, given $n$, we would call the function $n$ times, as seen above.
 Each time with $O(1)$ work in each function call.
 Total = $n$ calls with $O(1)$ work each => $O(n)$ total time complexity.
 We are using up extra space.
 We use as much extra space as:
 Number of possible unique calls to the recursive function * space required for each value.
 Since there are $n$ unique calls possible with an int value, space would be $O(n)$.
 I have hardcoded a limit of 20 in my code. We can also use a Vector etc.
That’s it. We just optimized the recursive code from a $O(2^n)$ time complexity, $O(n)$ space complexity (recursive call stack space) to an $O(n)$ time, $O(n)$ space (recursive + extra space).
Example with a higher number of parameters
1 2 3 4 5 6 7 

Time complexity: $O(3^{n+m})$ [Work it out on paper, why this would be the complexity, if you are not sure.]
DP Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 

 Number of unique calls: $O(nm)$
 Space Complexity: $O(nm)$
 Time Complexity: $O(nm)$
Assume I tweak foo and add an $O(n \log m)$ work inside each call, that would just be multiplied for the time complexity, i.e.,
Time complexity = O(unique calls) * O(workpercall)
$Space Complexity = O(unique calls) * O(space per call)
Now just reinforce these ideas with this question
 Given a rectangular grid of size N x M,
 What is the length of the longest path from bottomleft corner (0, 0) to topright corner (N  1, M  1), assuming you can go up, right, diagonally?
Extra Credit
What we saw is called topdown DP, because we are taking a bigger problem, breaking it down into subproblems and solving them first. This is basically recursion with memoization (we ‘memoize’ (fancy word for caching) the solutions of the subproblems).
When you absolutely, totally nail the recursive solution, some interviewers might want a solution without recursion. Or, probably want to optimize the space complexity even further (which is not often possible in the recursive case). In this case, we want a bottomup DP, which is slightly complicated. It starts by solving the smallest problems iteratively, and builds the solution to bigger problems from that.
Only if you have time, go in this area. Otherwise, even if you mention to the interviewer that you know there is something called bottomup DP which can be used to do this iteratively, they should be at least somewhat okay. I did a short blogpost on converting a topdown DP to a bottomup DP if it sounds interesting.