json might not be the best choice for on-disk formats; The trouble it has with appending data is a good example of why this might be. Specifically, json objects have a syntax that means the whole object must be read and parsed in order to understand any part of it.

Fortunately, there are lots of other options. A particularly simple one is CSV; which is supported well by python's standard library. The biggest downside is that it only works well for text; it requires additional action on the part of the programmer to convert the values to numbers or other formats, if needed.

Another option which does not have this limitation is to use a sqlite database, which also has built-in support in python. This would probably be a bigger departure from the code you already have, but it more naturally supports the 'modify a little bit' model you are apparently trying to build.

I suspect you left out that you're getting a TypeError in the blocks where you're trying to write the file. Here's where you're trying to write:

with open('offline_post.json','a') as f:
    new = json.loads(f)
    new.update(a_dict)
    json.dump(new,f)

There's a couple of problems here. First, you're passing a file object to the json.loads command, which expects a string. You probably meant to use json.load.

Second, you're opening the file in append mode, which places the pointer at the end of the file. When you run the json.load, you're not going to get anything because it's reading at the end of the file. You would need to seek to 0 before loading (edit: this would fail anyway, as append mode is not readable).

Third, when you json.dump the new data to the file, it's going to append it to the file in addition to the old data. From the structure, it appears you want to replace the contents of the file (as the new data contains the old data already).

You probably want to use r+ mode, seeking back to the start of the file between the read and write, and truncateing at the end just in case the size of the data structure ever shrinks.

with open('offline_post.json', 'r+') as f:
    new = json.load(f)
    new.update(a_dict)
    f.seek(0)
    json.dump(new, f)
    f.truncate()

Alternatively, you can open the file twice:

with open('offline_post.json', 'r') as f:
    new = json.load(f)
new.update(a_dict)
with open('offline_post.json', 'w') as f:
    json.dump(new, f)

You can't modify the json content like that. You'll need to modify the data structure and then completely rewrite the json file. You might be able to just read the data from jsone at startup, and write it at shutdown.

import json

def store_my_data(data, filename='test.json'):
    """ write data to json file """
    with open(filename, mode='w', encoding='utf-8') as f:
        json.dump(data, f)

def load_my_data(filename='test.json'):
    """ load data from json file """
    with open(filename, mode='r', encoding='utf-8') as f:
        return json.load(f)
    raise Exception # skipping some steps here

test_data = [
   {"name": "alan", "job": "clerk"},
   {"name": "bob", "job": "engineer"}
]
item_one = test_data[0]
item_two = test_data[1]

# You already know how to store data in a json file.
store_my_data(test_data)

# Suppose you don't have any data at the start.
current_data = []
store_my_data(current_data)

# Later, you want to add to the data.
# You will have to change your data in memory, 
# then completely rewrite the file.
current_data.append(item_one)
current_data.append(item_two)
store_my_data(current_data)

Quite simply: parse your json to get a Python object, update the python object, and dump it back to json.

import json
with open("myfile.json") as f:
    obj = json.load(f)
obj["users"].append({"name":"was that so complicated, really ?"})
with open("myfile.json", "w") as f:
    json.dump(f, obj)

I understand this might be a bit less obvious for a beginner, but given json specs, you can easily understand why the only reliable way to modify a json content is to actually parse it. Appending to the file won't work obviously as you already noticed (you'll get invalid json). Trying to read the file line by line, detect the end of the user array and insert a newline here won't work either (or only accidentally) since the json format does not mandate newlines anywhere, so you could as well have everything crammed in one single line ie:

{"users":[{"name":"test"},{"name":"test2"}]}

wrt/ memory comsuption / perfs etc, json is not designed for huge datasets anyway (you want jsonlines or something similar for this) so you shouldn't worry about it - and that's your only option anyway.

Take a look at json lines, its a format that matches what you need
https://jsonlines.org/examples/

In a jsonl file, every line by itself is a valid json, that way you can just

# to read
data = []
with open('my_file.jsonl') as f:
    for line in f:
        data.append(json.loads(line))

# to write a new line
with open('my_file.jsonl', 'a') as f:
    f.write(json.dumps(some_data) + '\n')

That way to can append items to the "array" without reading it first