Needless to say, that adding numbers in their string form is impractical since modern CPUs are capable of performing regular number addition in a single cycle. This algorithm is therefore interesting only as a brain teaser, if you want to get it to run as fast as possible.

The time complexity is indeed quadratic since
ans = str(number % 10) + ans
and
ans = str(number) + ans
create new string objects (and complexity of this is linear).

Instead of creating a new string each time you can append new characters to a list and do a ''.join(char_list) at the end. Complexity of adding to the list is constant and join is linear but you only run it once, so the resulting complexity is linear.

Space complexity will obviously be linear too.

This doesn't have to be a member function since you never use self in its body.

Indexing

You are looping though the characters of num1 and num2 backwards. Instead of using indices n1 and n2, the Pythonic way is to use reverse iterators: reversed(num1) and reversed(num2).

Zip

Moreover, in each iteration, you are taking one character from each. This sounds like a job for zip!

Longest

However, you must continue until you've processed all the characters of both strings, so this is a job for itertools.zip_longest(...).

Zero Filled

When one string is shorter than the other, you use a trinary statement like n1_digit = int(num1[n1]) if n1 >= 0 else 0 to fill in zeros value for the shorter string. zip_longest() has a fillvalue= option which will do this automatically.

PEP-8

According to The Style Guide for Python Code, function identifiers should be in snake_case -- not bumpyWords -- so the function should not be named addStrings.

Updated code

Using the above (plus suggestions from QuasiStellar answer), we can create a more Pythonic version of your function:

from itertools import zip_longest

def add_strings(num1: str, num2: str) -> str:
    carry = 0
    ans_digits = []

    for digits in zip_longest(*map(reversed, (num1, num2)), fillvalue='0'):
        carry, digit = divmod(sum(map(int, digits)) + carry, 10)
        ans_digits.append(digit)

    if carry:
        ans_digits.append(carry)

    return ''.join(map(str, reversed(ans_digits)))