Although the function is recursive (it calls itself), it does so in a pointless, ineffective way.

Consider what happens for any value of the counter when greater than 1:

def getFixedPayment(balance, annualInterestRate, counter=12):
    totalLoan = balance + (balance*annualInterestRate)
    monthlyPayment = roundup(totalLoan/12.0)
    newBalance = totalLoan - monthlyPayment

    if counter < 12:
        newPayment = newBalance / counter + 1
    else:
        newPayment = newBalance / counter

    if counter == 1:
        return roundup(newPayment/12)
    else:
        return getFixedPayment(balance,annualInterestRate,counter-1)
        #                                                 ^^^^^^^^^
        #                                                 the only change!

When counter > 1, the function "does some calculations", but it doesn't matter, because in the end it just calls itself with counter - 1. So for a starting value of counter = 12, the function will repeatedly call itself 11 times for nothing. As such it reduces to this:

def getFixedPayment(balance, annualInterestRate):
    totalLoan = balance + (balance*annualInterestRate)
    monthlyPayment = roundup(totalLoan/12.0)
    newBalance = totalLoan - monthlyPayment

    newPayment = newBalance / counter + 1

    return roundup(newPayment/12)

Can this possibly give correct answer? Not likely.

Consider how the repayment works. Let's take a simpler example of repaying something in 3 steps, and consider this alternative notation so it's simpler to write:

• Let's call T the total amount to pay today
• Let's call r the multiplier of the annual interest rate, that is for a 4% annual interest rate, this value will be 1.04, so we can get the amount that needs to be paid by T * r.
• Let's call x the target fixed monthly payment

After we pay x this month, how much will be left to repay?

(T - x) * r

That is, we pay x this month, the remaining amount is T - x, and as per the description we need to multiply with the annual interest rate.

Next month, we pay x again, so what's left to repay will be:

((T - x) * r - x) * r

In the third month we make the last payment of x.

The target of the exercise is to find the x such that:

((T - x) * r - x) * r - x <= 0

Let's reorganize this equation to find the value of x:

((T - x) * r - x) * r <= x

(T - x) * r - x <= x / r

(T - x) * r <= x / r + x

T - x <= x / r / r + x / r

T <= x / r / r + x / r + x

T <= x * (1 / r / r + 1 / r + 1)

T / (1 / r / r + 1 / r + 1) <= x

In this example we repay in 3 months. You can see how this formula changes by adding one month:

T / (1 / r / r / r + 1 / r / r + 1 / r + 1) <= x

That is, given T / m, adding one month means T / (m / r + 1).

Now that looks like a recursive logic we can use.

Without completely spoiling the exercise for you, here's a template of the solution where you just need to figure out the correct values for the .... Good luck!

def getFixedPayment(balance, annual_interest_rate, counter=12, interest=...):

    if counter == 1:
        return roundup(balance / interest)

    monthly_interest_rate = annual_interest_rate / 12
    r = 1 + monthly_interest_rate

    return getFixedPayment(balance, annual_interest_rate, counter - 1, ...)

And here are some doctests to verify your solution. If your program is in a file called calc.py, you can run the doctests with python -mdoctest calc.py. It will print a summary of the failing test cases if any, or it will print nothing if all good.

def getFixedPayment(balance, annual_interest_rate, counter=12, interest=...):
    """
    >>> getFixedPayment(3329, 0.2)
    310

    >>> getFixedPayment(4773, 0.2)
    440

    >>> getFixedPayment(3926, 0.2)
    360

    >>> getFixedPayment(265, 0.18)
    30

    >>> getFixedPayment(263, 0.18)
    30

    >>> getFixedPayment(317, 0.25)
    30

    >>> getFixedPayment(720, 0.2)
    70

    >>> getFixedPayment(4284, 0.2)
    400

    >>> getFixedPayment(3834, 0.15)
    350

    >>> getFixedPayment(3045, 0.18)
    280

    >>> getFixedPayment(4461, 0.2)
    410

    >>> getFixedPayment(4657, 0.04)
    400

    >>> getFixedPayment(3395, 0.2)
    310

    >>> getFixedPayment(4045, 0.15)
    370

    >>> getFixedPayment(3963, 0.18)
    360

    """

    if counter == 1:
        return roundup(balance / interest)

    monthly_interest_rate = annual_interest_rate / 12
    r = 1 + monthly_interest_rate

    return getFixedPayment(balance, annual_interest_rate, counter - 1, ...)

One problem is that:

Assume that the interest is compounded monthly

but you calculate:

totalLoan = balance + (balance*annualInterestRate)

You cannot calculate the totalLoan that way. You should take compound interest into account, and calculate the unpaid balance each month.

Naive approach

Here's an example. Note that your recursion can be replaced by a simple loop:

def balance_after_a_year(balance, monthly_payment, annual_interest_rate):
    monthly_interest_rate = annual_interest_rate / 12.0
    for month in range(12):
        balance = (balance - monthly_payment) * (1 + monthly_interest_rate)
    return balance

print(balance_after_a_year(3834, 340, 0.15))
# 23.153402858591026
print(balance_after_a_year(3834, 350, 0.15))
# -107.05775649703746

You can now use this function in a naive way. Simply iterate from 0 to balance in steps of 10, and pick the first value for which the balance after a year is negative:

def getFixedPayment(b,r):
    return next(m for m in range(0, b, 10) if balance_after_a_year(b, m, r) <= 0)
print(getFixedPayment(3834, 0.15))
# 350

This method has been validated with doctest provided by @janos.

There are more efficient methods but this one is simple and concise.

Monthly payment formula

You can calculate the montly payment directly with the monthly payment formula:

def getFixedPayment(b,r):
    m = r / 12.0
    return m * b / (1 - (1 + m)**-12)
print(getFixedPayment(3834, 0.15))
# 346.05036953133276

No need for any loop!