The Single Context Problem

In the world of financial management, account-based systems are the backbone of tracking and organizing monetary transactions. However, these systems face a challenge known as the Single Context Problem. This issue becomes increasingly significant as businesses grow and expand their operations. In this article, we'll explore the problem, why it's important, and introduce a revolutionary solution called String Theory. To help illustrate these concepts, we'll use visual diagrams at key points.

Defining the problem

To put it simply, the Single Context Problem can be summarized as follows:

Money within an account can only be fully understood within the context of that account.

In other words, if you have money in an account, all the information about that money must come from the account itself. This seemingly straightforward concept leads to two significant challenges, especially in larger systems:

• Uniform context: All money within an account shares the exact same context, no more and no less.
• Context loss: When money moves to a new account, it loses any context not shared by the new account.

Why does it matter?

Initially, it seems logical that money within an account should align with that account's purpose. However, the problem becomes evident as businesses expand. To illustrate this, we'll use a fictional business that sells cookies.

In this simple setup, we have three primary accounts: Revenue, Profit, and Expenses. This structure might suffice for a small business with a single product or service. However, as businesses evolve, so do their financial complexities. Let's add a second product to our cookie business and see how we need the accounts to evolve.

Our bakery business decides to add cupcakes to the menu. With this addition, the existing account structure falls short. We need to differentiate between cookie and cupcake revenue which leads to the following changes:

• The revenue account splits into cookie revenue and cupcake revenue.

While this solution addresses the immediate issue, it introduces new challenges:

• Tracking transactions between accounts becomes important.
• Determining profit for specific products requires manual calculations
• Some expenses aren't product-specific, causing confusion

The intuitive solution here might be to add more accounts, but it compounds the problems.

A growing nightmare

Expanding a business to multiple locations, or adding more products reveals the exponential complexity caused by the Single Context Problem. Let's follow through from the previous example and see if we can add accounts to solve our current problems.

We now have nicely categorized places to put things, and most of our problems are solved. It's not clear where fixed expense money comes from in this structure, but we'll pull it out of cookie revenue for the moment, since that's most of our business.

Why did we need cookie revenue and cupcake revenue? Since money doesn't maintain context as it moves between accounts if all we have is a generic profit account, we can't tell which product that profit is from. Every time we want to add a new way to understand our money, we need to split up all accounts below it by that new dimension as well. This is the practical impact of the Single Context Problem on most systems.

Good news! Our business is doing well now and we are ready to expand to a second location. We want to be able to understand our money by product and by location now so we come up with a new set of accounts.

As shown in this diagram even with just two locations and two products, we already require 16 accounts to maintain detailed financial records. Expanding further will exacerbate the problem, making it grow to an unmanageable size.

The traditional solution

Real-world businesses often cope with this complexity by limiting the number of categories represented in their systems. This trades the ability to understand the money in a more detailed way, in order to simplify the account structure. This approach, however, cannot provide the detailed information needed for modern business intelligence. Vast data pipelines or secondary systems are constructed to try to understand the context the simplified account structure intentionally gives up.

The new solution - String Theory

String Theory uses a revolutionary system that allows context to be maintained throughout the entire lifecycle of money in your system. Allowing you to have the best of simplified account structure, and detailed data.

In our next blog post Sticky Context we'll dive deeper into how String Theory handles context and explore its positive implications for managing financial data.