When the Software Doesn't Remember

When the software forgets, the user becomes the source of truth.

An architectural case study in what happens when an accounting system has multiple versions of the same financial reality.

I've been working with an accounting team recently, helping them work through problems in their accounting software. I went into it expecting to learn more about the business and help solve some software problems along the way.

Instead, I've ended up learning accounting.

Not because I particularly wanted to become an accountant, but because eventually you have to understand the numbers if you're going to understand why the software keeps producing problems around them.

And the more I learned, the more I started to see that many of the problems weren't really accounting problems at all.

They were architecture problems.

The system has owner statements, trial balances, expenses, disbursements, folios, reservations, and a posting journal. Each of these has a legitimate purpose. There is nothing wrong with having multiple views of a financial system. In fact if it didn’t I don’t think it would be much of a financial system at all.

The problem is that they don't always behave like different representations of the same underlying reality.

They can behave more like separate versions of reality that are expected to stay synchronized.

When they don't, someone has to reconcile them.

And that someone is the human sitting in front of the software.

Suppose an owner statement doesn't look right.

The natural thing to do is investigate the statement, find the transaction that is wrong, correct it, and regenerate the statement.

Except the statement isn't necessarily where the money is actually being calculated. You need to look at the trial balance to determine what should be paid, and sometimes the trial balance doesn't agree with the owner statement.

Now you're comparing one part of the accounting system against another to figure out which one represents the truth.

Maybe the statement needs to be regenerated. But regeneration itself isn't necessarily reliable. Changes may not appear until the statement is regenerated, and regeneration can sometimes fail without giving you a useful indication.

So you can end up in a particularly unpleasant situation where the system looks fine from the outside, but the underlying information is stale.

At that point, the question isn't simply "What is the correct number?"

It's "Which part of this system can I trust right now?"

That's when the human starts becoming the reconciliation layer.

Eventually, you end up in the posting journal.

This feels like the place where things should become clear. The journal is where the underlying accounting events live, so it should give you something you can trace back to when the higher-level views don't make sense.

Except now you discover that an expense can exist in the expense module without necessarily appearing in the posting journal.

  • Someone has to notice that.
  • Someone has to figure out what happened.
  • Someone has to manually add the missing accounting entry.

Now the problem is bigger than a stale report.

You have two representations of the same business event, and the user has to keep them synchronized.

That raises a fundamental architectural question:

What exactly is an expense in this system?

  • Is it an accounting event?
  • Is it an input that generates an accounting event?
  • Is it a separate record that happens to be related to an accounting event?

Those distinctions matter.

If the posting journal is the source of financial truth, then the expense system should have a well-defined relationship to it. Though I would argue the posting journal should be the source of truth, and the expense report simply a specialized view into the entries that are expenses.

It shouldn't be possible for the business to have an expense that exists in one part of the system and effectively doesn't exist in another.

Now take something completely ordinary in the business.

A reservation changes.

The reservation moves from one home to another.

You would expect the expenses associated with that reservation to understand that relationship and move accordingly.

Instead, some expenses can remain attached to the old reservation.

And because the expense can't simply be edited, the correction becomes a deletion and recreation.

  1. 1Delete the old expense.
  2. 2Create a new one.
  3. 3Then check whether the new expense is reflected correctly.
  4. 4Then check the owner statement.

Something that should have been a change to a business relationship has turned into manual data maintenance.

The software isn't really managing the relationship for you.

You're managing it for the software.

And this is where the architecture starts to show itself.

Here's where the problem starts getting interesting.

Suppose you need to regenerate a folio because something upstream was wrong.

You can't just regenerate it.

The disbursement has to be undone first.

That sounds reasonable on its own. A disbursement represents money that has been paid, so you don't want to casually change the thing that payment was based on.

So you undo the disbursement.

Now you can regenerate the folio.

But the owner statement depends on the folio, so the owner statement needs to be regenerated too.

The simple correction has now become a chain:

And remember, we haven't actually fixed the original problem yet.

We're dismantling everything downstream of it just to get back to a state where the original correction is possible.

The system has rules everywhere, and most of them exist for good reasons. Don't modify something that has already been disbursed. Don't change a finalized record. Don't casually rewrite an accounting period.

Each rule makes sense.

But when you connect enough of it together around a flawed model, you don't get a safer system.

You get a maze that cuts the person trying to navigate it.

The rules that were supposed to prevent mistakes start making mistakes harder to correct.

None of this happens in a vacuum.

  • Someone has to close the books.
  • Someone has to pay the owners.
  • Someone has to investigate why two numbers don't match.
  • Someone has to remember which report is trustworthy.
  • Someone has to remember to regenerate the statement after a change.
  • Someone has to notice when regeneration silently didn't work.

And they have to do this again next month.

Then again the month after that.

This is the part I think we sometimes miss when we talk about software architecture.

We see dependencies on a diagram. The person in accounting experiences them as Tuesday afternoon.

  • Every architectural shortcut eventually becomes someone's manual process.
  • Every missing relationship becomes someone's spreadsheet.
  • Every unreliable synchronization becomes someone's reconciliation.
  • Every awkward correction becomes another piece of tribal knowledge that has to be passed from one person to the next.

And when that happens month after month, the software isn't just costing the business in development effort.

It's charging the people who use it.

Suppose the thing you need to correct happened in a previous accounting period.

Now another rule appears: the accounting period is locked.

Again, that rule makes sense.

You don't want people casually changing finalized accounting history.

So you unlock the period.

Make the correction.

And then you may discover that the change doesn't cleanly appear where you'd expect it to. The posting journal reflects the change, but the old statement and current statement don't necessarily tell the same story.

Now someone looking at the statements has to go digging through the journal to understand where a number came from.

That is more than an inconvenience.

An accounting system isn't just supposed to calculate a number. It needs to provide a coherent explanation for that number.

If the answer to "Where did this come from?" is "You need to know which underlying journal to inspect and understand why the reports didn't update the way you expected," then the system has pushed part of its accounting model into the user's head.

And that is dangerous.

The rules themselves aren't necessarily bad.

In fact, most of them are exactly the kinds of rules I would expect in serious accounting software.

  • Don't modify something that has already been disbursed.
  • Don't let users casually edit finalized records.
  • Don't rewrite closed accounting periods.
  • Don't allow arbitrary changes to financial history.

These are good safeguards.

But safeguards only work when the thing being safeguarded is modeled correctly.

If the underlying relationships are wrong, the rules can amplify the problem.

A rule designed to prevent an invalid change can make a valid correction impossible.

A dependency designed to protect financial data can turn a simple correction into a chain reaction.

A rule designed to preserve history can force users to dismantle historical records just to fix something that was wrong.

Eventually, the only way to fix the system is to start breaking the rules of the system.

That's the architectural irony that bothers me most.

The software builds a fence to keep you from making a mess, then makes you climb over the fence when you actually need to clean one up.

The deeper problem is not that the system has too many screens.

It's that there doesn't appear to be a clean enough relationship between them.

The posting journal, expenses, trial balances, folios, owner statements, and disbursements all represent different parts of the business.

But if each representation can drift from the others, then the business needs a person to reconcile them.

That person becomes the implicit source of truth.

  • They know which number is probably right.
  • They know which report needs to be regenerated.
  • They know which records have to be undone first.
  • They know when the system probably didn't update correctly.
  • They know what to check after making a correction.

That knowledge isn't in the architecture anymore.

It's in someone's head.

And that's an expensive place to put it.

The answer is to make each view's relationship to the underlying financial reality explicit.

If the posting journal is the source of truth, then other components should have clear responsibilities around it.

  • Expenses should create or represent accounting events.
  • Trial balances should be derived from the underlying ledger.
  • Owner statements should represent a defined collection of transactions at a defined point in time. Not just when the statement was generated. If a correction happens in the past that should show on the statement next month, not silently create invisible discrepancies.
  • Disbursements should represent actual payments.
  • Folios should represent the financial activity associated with the underlying reservation.

And importantly, historical artifacts should be stable.

When an owner statement is approved, it should represent what was true at that point in time.

If something changes later, that shouldn't require rewriting the past. It should create an adjustment that can be traced and explained.

That gives you a much better story:

  1. 1This is what happened.
  2. 2This is what we originally reported.
  3. 3This was wrong.
  4. 4This is the correction.
  5. 5This is the resulting balance.

That's what I mean by correcting history rather than changing history.

This is ultimately what good architecture is supposed to do.

It doesn't eliminate complexity.

It puts complexity in the right place.

The person in accounting shouldn't need to understand the broken relationship between each component.

They shouldn't need to remember that moving a reservation may require recreating an expense.

They shouldn't have to compare an owner statement against a trial balance to determine which one represents the correct amount.

They shouldn't need to know which downstream records have to be dismantled before making a legitimate correction.

Those are architectural concerns.

The software should know.

And if the software can't manage those relationships reliably, the complexity doesn't disappear.

It moves.

  • It moves into spreadsheets.
  • It moves into checklists.
  • It moves into month-end procedures.
  • It moves into Teams messages and tribal knowledge.
  • And eventually it moves into the people responsible for closing the books.

That's the real cost of bad architecture.

I want to be explicit about something because it's easy to read an architectural case study like this and assume the examples are hypothetical.

They're not.

I'm deliberately not naming the system, but this is a real accounting system I've been working with, and these are real problems we've encountered.

  • Owner statements that don't always agree with trial balances.
  • Expenses that can exist in one part of the system without making it into the posting journal.
  • Expenses that can't be edited and have to be deleted and recreated.
  • Expenses that don't always follow a reservation when it moves.
  • Folios that have to be regenerated before an owner statement can be regenerated. The three or four times a statement has to be regenerated for the changes to take.
  • Accounting periods that have to be reopened to correct historical problems.
  • Changes that can become difficult to explain unless you dig into the underlying journal entries, compare the original owner statements, and look through old emails about a particular reservation to figure out what happened.

And I've spent enough time helping the accounting team work through these problems that I've essentially learned the accounting along the way.

When the model is wrong, somebody has to compensate for it.

The biggest problem here isn't that the software has too many rules.

It's that the architecture has made the relationships between pieces of financial data the user's problem.

When an owner statement doesn't match a trial balance, someone has to reconcile them. When an expense doesn't follow a reservation, someone has to fix it. When a folio doesn’t regenerate properly, someone has to find it and fix it. When a historical correction doesn't flow cleanly through the system, someone has to investigate where the number came from.

The software hasn't eliminated that complexity.

It has simply moved it out of the code and into the people using it.

Good architecture doesn't make complexity disappear. It puts complexity in the right place.

A well-designed accounting system should be absorbing the complexity of maintaining relationships between transactions, statements, payments, periods, and history. The people using it should be focused on running the business and closing the books, not maintaining the internal consistency of the software.

Because these aren't problems you solve once.

They're problems someone has to deal with every month.

Every reconciliation takes time. Every manual correction creates another opportunity for error. Every workaround becomes another process someone has to remember. Eventually, the software develops a shadow layer of procedures that exist solely because the underlying system can't reliably maintain itself.

And that is where architectural problems become business problems.

The cost isn't just that something is inconvenient.

It's the hours spent figuring out what happened. The repeated checks. The spreadsheets. The institutional knowledge. The month-end workarounds. The person who knows exactly which sequence of steps has to happen because they've been burned by it before.

That's what makes architecture matter.

The code may be hidden from the accounting team, but the consequences of the architecture aren't.

They experience it every time they have to reconcile something that should already agree. Every time they have to undo one thing to fix another. Every time they have to work around a system instead of simply using it.

And that's probably the biggest lesson I've taken from working through this system:

The quality of an architecture isn't just measured by what the software can do. It's measured by how much complexity it makes the people using it carry.

If the system is well designed, the architecture carries that weight.

If it isn't, the people do.

And after working with accounting to carry that weight month after month, I think that's a much more meaningful way to understand the consequences of bad architecture.

Bad architecture is the bugs it makes possible and the complexity it makes people remember.

The user shouldn't be the reconciliation layer.

This is what happens when the system doesn’t remember.

Read the first piece

What the System Should Remember

If your team is reconciling what the software should already agree on, we'd be glad to take a look.

Start a Conversation