There are two easy binary search approaches and one hard.

Easy 1.

Always maintain closed interval and the best answer outside this interval. Your template will be:

left = min_possible_answer
right = max_possible_answer
ans = null
while (left <= right) {
  mid = (left + right) / 2
  if (condition(mid)) {
    ...  
  } else {
    ...
  }
}
// ans contains null if there is no answer, otherwise it's the answer

Instead of dots:

• Write left = mid + 1 and right = mid - 1 depending on your condition. It's always easy to see in which branch left or right border should be reassigned.
• In one of the branches, also write ans = mid. Again, it's always easy to see in which one. If mid would be the better answer then ans, assign.

Easy 2.

It's called binary lifting. The template looks like this:

step = 1 << 30 // or 1LL << 60 or 1 << 20, just take the power of 2 which is > length_of_interval
ans = min_possible_answer - 1
while (step > 0) {
  if (isGood(ans + step)) {
    ans += step
  }
  step /= 2
}
// if ans is min_possible_answer - 1, there is no answer, otherwise it's the answer

I don't think this even requires any comments, it's just obvious. Absolutely no +/-1 errors.

Hard.

Let's wait when some red appears and writes it's the only true way. Who cares when you can literally make a mistake in EVERY expression.

I often use the second loop condition, while (low <= high), and the first way to find index of the middle element, mid = (low+high)/2. To update one of the limits, either low = mid+1 or high = mid-1, it is sufficient to keep in mind that the function $$$f$$$ computed at mid should be non-decreasing function, i.e. $$$f(mid-\delta) \leq f(mid) \leq f(mid+ \delta)$$$ for any positive value $$$\delta$$$.