<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Teo Bebekis on Medium]]></title>
        <description><![CDATA[Stories by Teo Bebekis on Medium]]></description>
        <link>https://medium.com/@teo.bebekis?source=rss-48fe592c1753------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*65GlwVYIYFBSJDKX</url>
            <title>Stories by Teo Bebekis on Medium</title>
            <link>https://medium.com/@teo.bebekis?source=rss-48fe592c1753------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 07:26:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@teo.bebekis/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[A Database Table Is Not a Business Object]]></title>
            <link>https://medium.com/@teo.bebekis/a-database-table-is-not-a-business-object-76ac16291dad?source=rss-48fe592c1753------2</link>
            <guid isPermaLink="false">https://medium.com/p/76ac16291dad</guid>
            <category><![CDATA[business-app-development]]></category>
            <dc:creator><![CDATA[Teo Bebekis]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 19:22:10 GMT</pubDate>
            <atom:updated>2026-11-18T19:34:37.604Z</atom:updated>
            <content:encoded><![CDATA[<p>You have a Customers table. Do you have a Customer?</p><p>You have a SalesOrder table. Do you have a Sales Order?</p><p>If your answer is “yes, because that is where they are stored,” you have treated two different things as one. Even experienced developers make this mistake.</p><p>A table stores data. A business object also defines what can be done with that data.</p><p>The difference becomes clear when the application needs to do more than update a record.</p><h3>What Does a Table Describe?</h3><p>A table describes the structure of its data. It has columns with specific types, keys, and relationships with other tables. The database can enforce constraints and protect data integrity.</p><p>The SalesOrder table may have a Status field. It may also record who changed the order, along with the reason for the change.</p><p>Those fields alone, however, do not define the order’s behavior. Status stores a value. Someone still needs to define who may change it and under what conditions.</p><p>Even if some of this behavior is implemented in the database, it remains a separate responsibility from storage.</p><p>The problem begins when we assume that designing the table means we have also defined the Sales Order.</p><h3>What Is a Business Object?</h3><p>A business object represents something with a specific meaning in the operation of a business. A Sales Order is one such object. The application needs to understand its behavior as well as its data structure.</p><p>This does not mean everything must fit inside a single SalesOrder class. It means the order needs a clear, consistent definition, regardless of which part of the application uses it.</p><p>Let us look at what that definition includes. We will use a Sales Order as our example, but similar concerns apply to other business documents, such as Invoices and Delivery Notes.</p><h3>1. It Has Identity</h3><p>An order remains the same order even if its delivery address changes or a line is added.</p><p>An internal ID = 1042 allows the system to identify it. People may use an order number, perhaps together with a document series or year. These ways of identifying the order are related, but they serve different needs.</p><p>Identity allows us to refer to the same order throughout its life, despite changes to its data.</p><h3>2. It Has State</h3><p>An order may start as a Draft and require approval before it can be fulfilled. Its exact lifecycle depends on how the business operates.</p><p>The allowed transitions need to be defined. In a particular system, for example, canceling an order that has already been invoiced may require a reversal process first.</p><p>That restriction is part of the order’s behavior. It must apply whether cancellation is requested through a form or through an API.</p><p>If each entry point makes its own decisions about what is allowed, the application ends up with different versions of the same Sales Order.</p><h3>3. It Has Rules</h3><p>Can a user change the price after approval? Can a line be added after shipping has started?</p><p>The answers come from how the business operates. The database schema alone cannot provide them.</p><p>The UI may ask the application whether an action is allowed so it can give the user immediate feedback. When executing the action, the application must check and enforce the applicable business rules, regardless of any earlier check requested by the UI. Disabling a button does not protect against a request coming from elsewhere.</p><p>What matters is having one authoritative definition of the rule. Independent implementations of the same rule can easily drift apart over time.</p><h3>4. It Has Actions</h3><p>An order is not limited to Insert, Update, and Delete.</p><p>A user asks to approve or cancel it. They may also ask to create a Delivery Note from it.</p><p>Approval will probably cause database updates. But the word “update” does not explain what that action means to the business.</p><p>The Approve action has specific preconditions and outcomes. It includes checking the user&#39;s authority and should record who took responsibility for the approval.</p><p>The action’s name expresses the intent. The database updates implement its result.</p><h3>5. It Has History</h3><p>An order’s current state does not necessarily explain how it reached that state.</p><p>If a quantity changes from ten units to six, the latest value does not tell us whether the customer requested the change or there was an availability problem.</p><p>The required history depends on the business. Not every field change needs the same treatment. Approval of a business document, however, may require an explicit record because it assigns responsibility and allows a process to continue.</p><p>The application needs a deliberate policy about which parts of the order’s past it preserves. Otherwise, when a dispute arises, it may have only the latest stored snapshot.</p><h3>6. It Has Meaningful Relationships</h3><p>An order <em>has</em> lines. That relationship means more than being able to join two tables.</p><p>A line belongs to a particular order and contributes to its totals. Changing its quantity may affect the total amount.</p><p>If a draft order can be deleted, the application needs to define what happens to its lines. An approved order may follow a different rule.</p><p>Foreign keys help preserve the integrity of these relationships. Their business meaning also needs to be expressed in the application’s behavior.</p><h3>Why CRUD Is Not Enough</h3><p>CRUD describes basic data management operations. It is essential in many applications, but it does not fully describe the user’s work.</p><p>“Save this change” leaves open the question of whether the change is allowed. The application must answer that before carrying it out.</p><p>Without a consistent definition of the Sales Order, those decisions become scattered:</p><ul><li>A check in the form decides whether to enable a button.</li><li>A separate check in the API decides whether to allow the action.</li><li>A stored procedure applies its own version of the restriction.</li><li>A bulk update process bypasses some of those checks.</li></ul><p>This arrangement may work for a long time. The problem becomes visible when a rule changes and only some parts of the application are updated.</p><p>The same action is then allowed through one path and rejected through another. The maintenance problem now has a specific cause. The business model is fragmented, and its implementations have started to disagree.</p><h3>An Example</h3><p>Consider creating a Delivery Note from a Sales Order.</p><p>From a storage perspective, new records will be created. Some values will come from the order.</p><p>For the business, however, this is a document transformation. The application needs to determine exactly what will be transferred to the new Delivery Note.</p><p>The order may be for ten units, while the first shipment contains only six. The remaining units stay outstanding. A later shipment must account for what has already been fulfilled.</p><p>The Delivery Note needs a link to the source order at a level that supports quantity tracking. If it is canceled, the effect on the order’s fulfillment must be defined.</p><p>Depending on the system, the action may also update inventory. That consequence must be part of the process definition.</p><p>An insert is one implementation step. The CreateDeliveryNote action expresses the work that needs to be completed consistently.</p><h3>What to Take Away</h3><blockquote><em>The storage structure describes how we keep the data.</em></blockquote><blockquote><em>The business model describes what the data means and what we are allowed to do with it.</em></blockquote><p>When designing an application, it is worth examining the things the business works with before finalizing the tables.</p><p>Take a Sales Order and follow it from creation to completion. The questions that arise will lead to decisions that a table diagram alone cannot express.</p><p>The database schema will need to support those decisions. Its existence does not replace them.</p><p>I develop this approach in my book <a href="https://www.amazon.com/Business-Application-Fundamentals-Understanding-Software-ebook/dp/B0HF7LW9D6"><em>Business Application Fundamentals: Understanding the Systems Behind Business Software</em></a>, which examines what a business application is before choosing the technologies used to build it.</p><p>But even if you never read it, keep this in mind:</p><p>Do not confuse the table with the object.</p><p>PS. I wrote the original article in Greek and used AI assistance to revise it and translate it into English.</p><p><em>Originally published at </em><a href="https://teonotebook.wordpress.com/2026/11/18/a-database-table-is-not-a-business-object/"><em>http://teonotebook.wordpress.com</em></a><em> on November 18, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76ac16291dad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Web Was Never Designed for Business Applications]]></title>
            <link>https://medium.com/@teo.bebekis/the-web-was-never-designed-for-business-applications-16a746fa96c6?source=rss-48fe592c1753------2</link>
            <guid isPermaLink="false">https://medium.com/p/16a746fa96c6</guid>
            <category><![CDATA[desktop]]></category>
            <category><![CDATA[web]]></category>
            <category><![CDATA[design-thinking]]></category>
            <dc:creator><![CDATA[Teo Bebekis]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 09:50:02 GMT</pubDate>
            <atom:updated>2026-07-31T09:59:32.053Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/440/0*nZ0IFYtjRH7Ds06a" /></figure><p>The Web won the battle for the distribution of business software. An application can be installed on a server, updated in one place, and made immediately available to people working from different offices, cities, or countries. The browser is almost everywhere, and accessing an application does not require a separate installation on every computer.</p><p>This success often conceals a fundamental contradiction. The Web became the dominant platform for delivering business applications, even though it was not designed for the way they work.</p><p>The Web was designed around documents, pages, links, and independent requests. Business applications are environments for continuous work on data. They require long-lived state, active tasks, datasets, rules, commands, permissions, and controlled transitions between business states.</p><p>Today’s browser can host extraordinarily complex applications. To achieve this, however, we have to build inside it much of an application runtime that the Web did not provide by nature.</p><h3>Two Application Models, One Browser</h3><p>The term web application is used for two fundamentally different kinds of software. To discuss their differences clearly, we need to give them names.</p><p>The first is the <strong>document-oriented model</strong>. Such an application is organized around documents or pages, content, rendering, and navigation. The user visits a page, consumes content, follows links, and usually performs small, relatively independent interactions.</p><p>A news site, a blog, a public corporate website, and much of an online store follow this model. They may include dynamic content, search, user accounts, and forms. Their fundamental unit remains the page, or the content presented within it.</p><p>The second is the <strong>desktop-like application model</strong>. The term describes neither the application’s appearance nor the operating system on which it runs. It describes its model of interaction and work.</p><p>In a desktop-like application, the user works continuously. They open tasks and keep them active, edit data over extended periods, move among lists, forms, and business objects, execute commands, deal with validation errors, and manage changes that have not yet been saved. The application participates in processes with state, rules, permissions, and history.</p><p>The back office of an online store is a characteristic example. A visitor browsing products primarily uses a document-oriented application. An employee managing orders, inventory, returns, and payments uses a desktop-like application, even when both run in the same browser.</p><p>The distinction can be summarized simply.</p><blockquote><em>A document-oriented application is primarily visited and navigated.<br> A desktop-like application is primarily operated and worked in.</em></blockquote><p>The two types can coexist within the same system and share data and services. They remain, however, different application models. When they are treated as variations of the same problem, architectural discussions become vague and tools are judged by the wrong criteria.</p><h3>A Platform Built Around Documents</h3><p>The Web’s original architecture was designed to distribute and connect documents.</p><p>HTML describes documents. The DOM represents a document tree. URLs identify resources. HTTP is organized around independent requests and responses. Navigation moves the user from one page to another. The classic web form collects a limited set of values and submits them to the server.</p><p>This model is highly effective for content. A document can be requested, transferred, presented, and replaced by the next one. The state that must remain on the client is limited.</p><p>A desktop-like business application demands different things.</p><ul><li>Multiple active work areas.</li><li>Data that remains loaded and related.</li><li>Editing sessions containing both saved and unsaved changes.</li><li>Master-detail coordination.</li><li>Dirty tracking across fields, records, and object graphs.</li><li>Validation at different levels.</li><li>Commands whose availability depends on state and permissions.</li><li>Complex grids, lookups, and search tools.</li><li>Controlled lifecycles and business transitions.</li><li>Protection against concurrent work and conflicting changes.</li></ul><p>A user may be editing an order, open a customer’s record to check some information, return to the order, and continue from where they left off. The application must know which data is loaded, what has changed, which commands are allowed, and what should happen if the user closes an active task.</p><p>This is not navigation among documents. It is the management of state and work.</p><h3>Rebuilding an Application Platform Inside the Browser</h3><p>Modern browsers are powerful execution environments. JavaScript, Web APIs, and today’s frameworks make it possible to build applications that only a few years ago would have been considered exclusively desktop software.</p><p>This capability, however, does not erase the platform’s architectural origins. To host a desktop-like application, the browser must effectively acquire an application runtime.</p><p>JavaScript frameworks provide components, rendering, reactivity, routing, and general state-management mechanisms. These are important building materials. On their own, they do not constitute a model of business work.</p><p>Developers often need to select, combine, or build additional mechanisms for:</p><ul><li>datasets and field metadata,</li><li>editing state and change tracking,</li><li>master-detail coordination,</li><li>data-aware controls,</li><li>commands and command availability,</li><li>validation and error presentation,</li><li>lookup and reference resolution,</li><li>control lifecycles,</li><li>saving complex object graphs,</li><li>concurrency and transaction boundaries.</li></ul><p>Some of the complexity of a modern web application belongs to the business problem itself. Rules, permissions, processes, and data relationships would exist on any platform.</p><p>Another part is the cost of adaptation. It is the work required to turn a document-oriented environment into an application platform.</p><p>This distinction matters in practice. If we attribute all complexity to the business domain, we will never recognize which problems recur in every business application because the appropriate runtime is missing. We will continue solving them again in every project, using different combinations of libraries and local conventions.</p><h3>The Distinction the Web Literature Failed to Make</h3><p>Despite its practical importance, the distinction between the document-oriented and desktop-like application models has rarely been stated explicitly in Web literature and commentary. Discussions have been organized primarily around technologies and implementation mechanisms, such as server-side rendering, Single Page Applications, components, native clients, and cross-platform frameworks. Classifying the kind of application and the work it must support did not come first.</p><p>This was a taxonomic and architectural mistake. Every application that used HTTP and appeared in a browser was called a web application, as though sharing a platform implied sharing the same needs. As a result, techniques suited to distributing documents and content were applied to systems for continuous data processing, while rich-client architectures were proposed even for applications whose natural unit remained the page.</p><p>The public-facing side of an online store requires a fast initial display, search-engine discoverability, and effective content presentation. The back office of the same store requires stable editing sessions, dense data presentation, fast keyboard navigation, complex grids, validation, and safe business actions. A shared platform does not imply a shared application model.</p><p>The same confusion found its way into JavaScript libraries and frameworks. The ecosystem offered general mechanisms for components, rendering, routing, and state, but more rarely a coherent model for datasets, editing sessions, data-aware controls, commands, master-detail work, and controlled lifecycles. These capabilities can be built, but the creator of a business application is often left to assemble the corresponding runtime alone.</p><p>The late arrival of techniques such as virtual scrolling in grids is a simple example. Working efficiently with tens or hundreds of thousands of records is a common requirement in business software, but it was not an early priority for an ecosystem oriented mainly toward pages and content.</p><p>Many of these tools solve the problems for which they were designed effectively. Their generality, however, does not automatically make them suitable for every kind of application. The architectural decision must begin with the model of work and only then consider the implementation mechanism.</p><p>The correct order of questions is simple. First, we decide whether the application functions primarily as a document or as a program for continuous work. Then we decide whether it needs SSR, an SPA, hydration, a native client, or some combination of them. The literature and the ecosystem have all too often followed the opposite order.</p><h3>The Long Road Back to the Server</h3><p>The evolution of the JavaScript ecosystem illustrates the consequences of this confusion. Early web applications relied mainly on server-side rendering. The server produced the HTML, and the browser presented the result. This model was a natural fit for document-oriented applications, but it limited the immediacy and continuity of work required by many desktop-like applications.</p><p>Single Page Applications moved much of the rendering and interaction to the client. The initial page loaded a JavaScript runtime, which requested data and changed the interface dynamically. This approach enabled fast transitions, rich interaction, and state preservation without a full page reload.</p><p>The SPA was a reasonable response to the needs of desktop-like applications. The mistake was generalizing it into an almost self-evident architecture for every web application.</p><p>When much of the application moved into the browser, the client took responsibility for navigation, temporary state, caching, synchronization, communication error handling, and a substantial part of the application flow. Routers, state managers, package managers, bundlers, build pipelines, code splitting, and client-side caches became necessary to control the complexity. Each new addition solved real problems. Many of those problems, however, had been created or amplified by the previous transfer of ever more responsibilities to the client.</p><p>The browser thus began to operate as a second application server. At the same time, the application still had to keep authorization, definitive validation, and control of shared state on the actual server. The same logic often appeared on both sides, with different implementations and different lifecycles.</p><p>Newer approaches, such as hydration, partial hydration, islands, and server components, move parts of rendering and execution back toward the server. They address real problems involving initial load, performance, discoverability, and JavaScript volume. At the same time, they reveal that moving the entire application to the client was not the natural choice for every case.</p><p>After years of increasing client complexity, the ecosystem is rediscovering that server-side rendering is not an obsolete technique for many document-oriented applications. It is often the simpler and better architectural choice. Content arrives ready to display, navigation remains straightforward, and the client handles only the interaction that is genuinely needed.</p><p>For desktop-like applications, a rich client often remains necessary. A long-lived editing session, a complex grid, and immediate responses to continuous user actions require substantial execution on the client. An SPA, however, provides the container, not the business model. Components and reactive state are not equivalent to datasets, a command system, transaction boundaries, and a controlled lifecycle.</p><p>The return to the server does not prove that SPAs were entirely wrong. It proves that architecture must follow the kind of application. Document-oriented applications can use SSR and add client-side behavior where needed. Desktop-like applications can use a rich client, but they require a genuine application runtime and a centrally controlled business model.</p><p>The essential question is not whether the browser can execute more logic. It can. The question is which logic genuinely needs to be there.</p><h3>JSON Is Not the Problem</h3><p>Data transfer reveals the same confusion on a smaller scale.</p><p>JSON is simple, readable, and supported almost everywhere. It is an excellent fit for configuration, small object graphs, and many kinds of API responses. The problem begins when every set of business data is mechanically represented as an array of independent objects.</p><p>An equipment catalog can be transferred as follows.</p><pre>[<br>  {<br>    &quot;id&quot;: &quot;3ec5070e-cedd-49e9-95de-c3b249c5231a&quot;,<br>    &quot;code&quot;: &quot;EQ-104&quot;,<br>    &quot;name&quot;: &quot;Portable Projector&quot;,<br>    &quot;category&quot;: &quot;Presentation&quot;,<br>    &quot;available&quot;: true<br>  },<br>  {<br>    &quot;id&quot;: &quot;593c227a-c1bc-423a-8a53-03f984e86e65&quot;,<br>    &quot;code&quot;: &quot;EQ-127&quot;,<br>    &quot;name&quot;: &quot;Conference Speakerphone&quot;,<br>    &quot;category&quot;: &quot;Audio&quot;,<br>    &quot;available&quot;: true<br>  },<br>  {<br>    &quot;id&quot;: &quot;787085b0-b3cf-4b53-919a-d6cffaf98e8c&quot;,<br>    &quot;code&quot;: &quot;EQ-143&quot;,<br>    &quot;name&quot;: &quot;Document Camera&quot;,<br>    &quot;category&quot;: &quot;Presentation&quot;,<br>    &quot;available&quot;: false<br>  }<br>]</pre><p>The format is clean and convenient. For a small number of records, repeating property names has no practical significance.</p><p>In a large dataset, however, the same names are repeated in every row. Schema information remains implicit. The client must obtain types, captions, nullability, lengths, editability, and presentation rules from elsewhere. The representation also has no natural place for row state, original values, deleted rows, and change tracking.</p><p>JSON remains merely the format. The substantive decision is the model we choose to express within it.</p><h3>A Dataset Is More Than an Array of Objects</h3><p>A dataset is an organized collection of rows that share the same schema. Fields have names, types, and metadata. Rows can have state and participate in an editing session. This nature can be represented explicitly.</p><pre>{<br>  &quot;name&quot;: &quot;Equipment&quot;,<br>  &quot;fields&quot;: [<br>    {<br>      &quot;name&quot;: &quot;id&quot;,<br>      &quot;dataType&quot;: &quot;string&quot;,<br>      &quot;required&quot;: true,<br>      &quot;readOnly&quot;: true,<br>      &quot;visible&quot;: false<br>    },<br>    {<br>      &quot;name&quot;: &quot;code&quot;,<br>      &quot;dataType&quot;: &quot;string&quot;,<br>      &quot;caption&quot;: &quot;Code&quot;,<br>      &quot;required&quot;: true,<br>      &quot;maxLength&quot;: 20<br>    },<br>    {<br>      &quot;name&quot;: &quot;name&quot;,<br>      &quot;dataType&quot;: &quot;string&quot;,<br>      &quot;caption&quot;: &quot;Equipment&quot;,<br>      &quot;required&quot;: true,<br>      &quot;maxLength&quot;: 120<br>    },<br>    {<br>      &quot;name&quot;: &quot;category&quot;,<br>      &quot;dataType&quot;: &quot;string&quot;,<br>      &quot;caption&quot;: &quot;Category&quot;,<br>      &quot;required&quot;: true,<br>      &quot;maxLength&quot;: 60<br>    },<br>    {<br>      &quot;name&quot;: &quot;available&quot;,<br>      &quot;dataType&quot;: &quot;boolean&quot;,<br>      &quot;caption&quot;: &quot;Available&quot;,<br>      &quot;required&quot;: true,<br>      &quot;defaultValue&quot;: true<br>    }<br>  ],<br>  &quot;rows&quot;: [<br>    {<br>      &quot;state&quot;: &quot;unchanged&quot;,<br>      &quot;values&quot;: [<br>        &quot;3ec5070e-cedd-49e9-95de-c3b249c5231a&quot;,<br>        &quot;EQ-104&quot;,<br>        &quot;Portable Projector&quot;,<br>        &quot;Presentation&quot;,<br>        true<br>      ]<br>    },<br>    {<br>      &quot;state&quot;: &quot;modified&quot;,<br>      &quot;values&quot;: [<br>        &quot;593c227a-c1bc-423a-8a53-03f984e86e65&quot;,<br>        &quot;EQ-127&quot;,<br>        &quot;Conference Speakerphone&quot;,<br>        &quot;Audio&quot;,<br>        false<br>      ],<br>      &quot;originalValues&quot;: {<br>        &quot;available&quot;: true<br>      }<br>    },<br>    {<br>      &quot;state&quot;: &quot;inserted&quot;,<br>      &quot;values&quot;: [<br>        &quot;a64dc71c-3b37-4442-b28b-2140307e711d&quot;,<br>        &quot;EQ-151&quot;,<br>        &quot;Wireless Presentation Kit&quot;,<br>        &quot;Presentation&quot;,<br>        true<br>      ]<br>    }<br>  ],<br>  &quot;deletedRows&quot;: [<br>    {<br>      &quot;id&quot;: &quot;787085b0-b3cf-4b53-919a-d6cffaf98e8c&quot;,<br>      &quot;version&quot;: 4<br>    }<br>  ]<br>}</pre><p>The schema is transferred once. The values in each row follow the order of the fields, without repeating their names. Metadata can guide editors, validation, and presentation. The state of each row is expressed explicitly, while changes and deletions can be retained until the data is saved.</p><p>This representation is not proposed as a universal replacement for conventional JSON. For a small response or an independent object, it would often be unnecessarily complex. In an application that loads, presents, and edits large sets of homogeneous records, it expresses the nature of the data more accurately.</p><p>The benefit is not limited to reducing the payload. A dataset-aware runtime knows which fields exist, what they are called, which value types are expected, and which rows have changed. It can connect this data to grids, editors, validation, and commands without every screen inventing its own model.</p><p>Data representation is part of the architecture. When a business dataset is treated as an arbitrary collection of objects, its structure and behavior must be reconstructed elsewhere.</p><h3>Business Software Deserves Its Own Model</h3><p>Business software is one of the largest categories of software being built. Businesses and organizations need applications for sales, purchasing, inventory, finance, personnel, manufacturing, projects, services, approvals, and countless specialized tasks.</p><p>Despite its scale, business software is often described using general concepts such as pages, components, state, and API calls. These concepts are useful, but they operate at a lower level than the actual problem.</p><p>A business application is organized around business objects, datasets, references, rules, actions, lifecycles, roles, and persistent state. Users do not operate components. They submit requests, approve actions, reserve resources, correct information, and complete tasks.</p><p>Recognizing the desktop-like application model is neither a return to the desktop nor an attempt to imitate old user interfaces. It means recognizing continuous, stateful, data-intensive work as a distinct application model, regardless of the platform on which it runs.</p><p>A desktop-like application may be a native desktop, web, or tablet application. Conversely, a desktop application may be primarily document-oriented. The terms describe the nature of the interaction, not the delivery medium.</p><p>This distinction enables more precise decisions. A framework suited to content is not automatically suited to dense business work. A component library is not equivalent to a business application runtime. An API that serves independent resources well does not necessarily support object graphs, commands, and editing sessions.</p><p>Business software needs its own vocabulary and tools that recognize its recurring structures. Without them, every team builds fragments of the same foundation beneath its application screens.</p><h3>Use the Web for What It Does Best</h3><p>The Web remains an excellent delivery medium. Universal access, centralized deployment, immediate updates, and natural support for distributed users rightly explain its dominance.</p><p>The architectural conclusion is not that we should abandon the Web. It is that we should use it with an understanding of its nature.</p><p>The business model needs an existence independent of the browser and the UI framework. Data, relationships, rules, commands, and lifecycles must be defined in business terms. The UI is the projection of and interaction mechanism for that model, not the place from which the model emerges.</p><p>With this foundation, the same business model can support different presentation environments. The Web can provide broad distribution. A desktop client can take advantage of deeper integration with the operating system. A mobile client can serve selected tasks suited to the device and its context of use.</p><p>The choice of platform thus ceases to determine the nature of the application. The application retains its business model, and each client presents it in a way appropriate to its own environment.</p><p>The Web won because it can deliver business software everywhere. That does not mean it naturally understands business software.</p><blockquote><em>The Web won because it can deliver business software everywhere. That does not mean it naturally understands business software.</em></blockquote><p><em>Originally published at </em><a href="https://teonotebook.wordpress.com/2026/07/31/the-web-was-never-designed-for-business-applications/"><em>http://teonotebook.wordpress.com</em></a><em> on July 31, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16a746fa96c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fundamental Concepts of Business Applications IV: Building a Locator]]></title>
            <link>https://medium.com/@teo.bebekis/fundamental-concepts-of-business-applications-iv-building-a-locator-d9477b70d7a8?source=rss-48fe592c1753------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9477b70d7a8</guid>
            <dc:creator><![CDATA[Teo Bebekis]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 11:43:11 GMT</pubDate>
            <atom:updated>2026-07-07T12:02:37.795Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/440/0*hLBCBPMXNaYbK1i9" /></figure><h3>From declaration to runtime</h3><p>In the previous parts we examined the problem: a business application needs a reliable way to turn a human reference into a business entity.</p><p>A user types a customer code, a product name, a tax number, an external identifier, or a fragment of a description. The application needs to arrive at something stable: the canonical identity of the record.</p><p>That is the role of the Locator.</p><p>In the previous article we saw how a Locator can be described declaratively. We described fields, search fields, result fields, key field, and policies. But a definition by itself is just data. It needs a runtime.</p><p>In this article we move to the practical part:</p><pre>Locator Definition<br>        ↓<br>Runtime Request<br>        ↓<br>Execution Engine<br>        ↓<br>Locator Result</pre><p>We will see which objects are needed, what their roles are, how they cooperate, and how a declarative definition becomes an executable mechanism.</p><p>The article uses the Locator as a case study, but the idea is broader. Many business frameworks follow the same path: we describe something declaratively and then build a runtime that can execute it.</p><h3>1. The problem solved by the Locator</h3><p>In a sales application, the user may type:</p><p>or:</p><p>or select a row from a result list.</p><p>For the UI, these look like text input or a dropdown selection. For the business layer, they are something else: an attempt to resolve a reference.</p><p>The application wants to answer:</p><ul><li>Which record does this refer to?</li><li>Is there exactly one record?</li><li>Are there multiple records and should the user choose one?</li><li>Is the search too broad?</li><li>Is the request invalid?</li><li>Is there a context problem, such as wrong company or permissions?</li></ul><p>If this logic stays inside event handlers, SQL snippets, or controllers, the system fills with repetition and special cases. The Locator provides a stable runtime contract.</p><h3>2. The basic runtime pieces</h3><p>A Locator needs five basic objects:</p><pre>LocatorDefinition <br>LocatorRequest <br>LocatorContext <br>LocatorEngine <br>LocatorResult</pre><p>Their roles are clear:</p><ul><li>LocatorDefinition: describes what the locator knows.</li><li>LocatorRequest: describes what the caller is asking for now.</li><li>LocatorContext: carries runtime information.</li><li>LocatorEngine: executes the process.</li><li>LocatorResult: returns outcome and data.</li></ul><p>These objects are the minimum runtime model. They are more than classes for organizing code: they are the boundaries of the mechanism.</p><h3>3. LocatorDefinition</h3><p>The definition is the declarative part.</p><p>A simple shape:</p><pre>public class LocatorDefinition<br>{<br>    public string Name { get; set; }<br>    public string ClassName { get; set; }<br>    public string Source { get; set; }<br>    public string KeyField { get; set; }<br><br>    public List&lt;LocatorFieldDefinition&gt; Fields { get; } = new();<br>    public List&lt;string&gt; SearchFields { get; } = new();<br>    public List&lt;string&gt; ResultFields { get; } = new();<br><br>    public int MinimumSearchLength { get; set; }<br>    public int MaximumResultCount { get; set; }<br>    public string OrderBy { get; set; }<br>}</pre><p>Example:</p><pre>var customerLocator = new LocatorDefinition<br>{<br>    Name = &quot;Customer&quot;,<br>    ClassName = &quot;SqlLocator&quot;,<br>    Source = &quot;Customer&quot;,<br>    KeyField = &quot;Id&quot;,<br>    OrderBy = &quot;Name&quot;,<br>    MinimumSearchLength = 2,<br>    MaximumResultCount = 50<br>};<br><br>customerLocator.AddField(&quot;Id&quot;, FieldType.String);<br>customerLocator.AddField(&quot;Code&quot;, FieldType.String);<br>customerLocator.AddField(&quot;Name&quot;, FieldType.String);<br><br>customerLocator.AddSearchField(&quot;Code&quot;);<br>customerLocator.AddSearchField(&quot;Name&quot;);<br><br>customerLocator.AddResultField(&quot;Id&quot;);<br>customerLocator.AddResultField(&quot;Code&quot;);<br>customerLocator.AddResultField(&quot;Name&quot;);</pre><p>This code describes the Locator. Search, connection, UI, and result state belong to the runtime.</p><p>The definition answers:</p><ul><li>What is the locator name?</li><li>Which engine will execute it?</li><li>Which source will the engine use?</li><li>Which field is the canonical identity?</li><li>Which fields participate in search?</li><li>Which fields are returned?</li><li>Which policies apply?</li></ul><p>The definition stays stable. The request and context change on every execution.</p><h3>4. Name, ClassName, and Source</h3><p>The three fields Name, ClassName, and Source are easy to confuse, so it is worth separating them.</p><pre>Name <br>  locator identity in the registry <br><br>ClassName <br>  engine/handler type that will execute the definition <br><br>Source <br>  provider-specific source used by the engine</pre><p>Name is the registry key:</p><p>The runtime uses it to find the definition.</p><p>ClassName selects the engine:</p><pre>SqlLocator <br>ServiceLocator <br>ObjectLocator</pre><p>Source is input to the engine. For a SQL engine it may be a table:</p><p>or a select:</p><pre>select Id, Code, Name from Customer where IsActive = 1</pre><p>For a service engine it may be an endpoint:</p><pre>/api/customers/search</pre><p>For an object engine it may be the name of an in-memory collection.</p><p>The architecture remains provider-neutral. Interpreting Source belongs to the engine.</p><h3>5. LocatorRequest</h3><p>The request is the runtime intention of the caller.</p><p>A simple shape:</p><pre>public class LocatorRequest<br>{<br>    public object KeyValue { get; set; }<br>    public string SearchTerm { get; set; }<br>    public string SearchField { get; set; }<br>    public bool IsMultiRow { get; set; }<br><br>    public LocatorContext Context { get; set; } = new();<br>}</pre><p>KeyValue is used when the caller already has a possible canonical identity and wants to load or verify it.</p><p>SearchTerm is used for text search.</p><p>SearchField optionally limits the search to a specific field.</p><p>IsMultiRow gives a hint about the UI scenario, for example a grid lookup instead of a simple editor.</p><p>The request expresses the caller’s intention. Fields, policies, and source belong to the definition.</p><p>The request says:</p><pre>I want to resolve this now.</pre><h3>6. LocatorContext</h3><p>The context carries runtime conditions.</p><p>The same search may produce different results per company, branch, tenant, language, connection, date, or user permissions.</p><p>A practical shape:</p><pre>public class LocatorContext<br>{<br>    public string LocatorName { get; set; }<br><br>    public Dictionary&lt;string, object&gt; Parameters { get; } = new();<br>}</pre><p>Example:</p><pre>request.Context.LocatorName = &quot;Customer&quot;;<br>request.Context.Parameters[&quot;CompanyId&quot;] = currentCompanyId;<br>request.Context.Parameters[&quot;Language&quot;] = currentLanguage;<br>request.Context.Parameters[&quot;ConnectionName&quot;] = connectionName;</pre><p>The dictionary is a practical choice. The context works as a runtime carrier, not as an entity schema. It needs room for parameters that vary per application or provider.</p><p>In stricter implementations there may be a strongly typed context. The basic contract remains the same: the context brings information that affects execution.</p><p>LocatorName in the context is registry identity. The runtime uses it to find the definition.</p><h3>7. LocatorResult</h3><p>The result is an outcome, not just a list.</p><p>A search function usually returns rows. A Locator must return the state of the resolution attempt.</p><p>A simple shape:</p><pre>public class LocatorResult<br>{<br>    public LocatorResultStatus Status { get; set; }<br>    public string Message { get; set; }<br><br>    public object Data { get; set; }<br><br>    public int Count { get; set; }<br>}</pre><p>The basic states:</p><pre>public enum LocatorResultStatus<br>{<br>    None,<br>    InvalidRequest,<br>    InvalidContext,<br>    NoResult,<br>    SingleResult,<br>    MultipleResults,<br>    TooManyResults,<br>    Error<br>}</pre><p>The distinction has practical value:</p><ul><li>NoResult: the request was valid, but the search returned an empty result.</li><li>SingleResult: one record was found and the reference was resolved.</li><li>MultipleResults: a small set of records was found and the user can choose.</li><li>TooManyResults: the search was too broad.</li><li>InvalidRequest: input is missing or invalid.</li><li>InvalidContext: the runtime context is incomplete or incompatible.</li><li>Error: a technical or unexpected failure.</li></ul><p>The UI can react differently to each state.</p><p>For example:</p><pre>SingleResult<br>    write CustomerId and related fields<br><br>MultipleResults<br>    show selection list<br><br>TooManyResults<br>    ask for more characters<br><br>NoResult<br>    show message or allow new record</pre><p>This is where the Locator becomes a business mechanism instead of a simple search helper.</p><h3>8. LocatorEngine</h3><p>The engine executes.</p><p>A clean contract:</p><pre>public abstract class Locator<br>{<br>    public abstract LocatorResult Execute(<br>        LocatorDefinition definition,<br>        LocatorRequest request);<br>}</pre><p>The engine receives a definition and a request. The context is inside the request.</p><p>Its role:</p><pre>Validate Request<br>Read Definition<br>Apply Context<br>Resolve<br>Produce Canonical Identity<br>Produce Projection<br>Determine Result State<br>Return Result</pre><p>The implementation may be SQL, service, object, cache, directory, or something else.</p><p>The contract remains the same.</p><h3>9. Facade, Registry, and Factory</h3><p>The caller needs a simple entry point.</p><p>The facade takes responsibility for:</p><pre>find definition<br>validate definition<br>create engine<br>execute engine<br>interpret result</pre><p>It needs an application-level service.</p><p>Example:</p><pre>public static class Locators<br>{<br>    public static LocatorResult Execute(LocatorRequest request)<br>    {<br>        if (request == null)<br>            throw new ArgumentNullException(nameof(request));<br><br>        if (request.Context == null)<br>            return LocatorResult.InvalidContext(&quot;Missing locator context.&quot;);<br><br>        if (string.IsNullOrWhiteSpace(request.Context.LocatorName))<br>            return LocatorResult.InvalidContext(&quot;Missing locator name.&quot;);<br><br>        LocatorDefinition definition =<br>            LocatorRegistry.Get(request.Context.LocatorName);<br><br>        definition.Check();<br><br>        Locator locator =<br>            LocatorFactory.Create(definition.ClassName);<br><br>        return locator.Execute(definition, request);<br>    }<br>}</pre><p>The roles:</p><ul><li>Registry: finds a definition by locator name.</li><li>Factory: creates an engine based on ClassName.</li><li>Facade: gives the caller a simple entry point.</li><li>Engine: executes resolution.</li></ul><p>This keeps UI and callers clean.</p><h3>10. The execution pipeline</h3><p>Now let us look at the pipeline as practical steps.</p><pre>Caller<br>  ↓<br>LocatorRequest<br>  ↓<br>LocatorContext.LocatorName<br>  ↓<br>LocatorRegistry<br>  ↓<br>LocatorDefinition<br>  ↓<br>LocatorFactory<br>  ↓<br>LocatorEngine<br>  ↓<br>LocatorResult</pre><h3>Validate Request</h3><p>The engine checks input first.</p><p>Example:</p><pre>if (request.KeyValue == null &amp;&amp;<br>    !string.IsNullOrWhiteSpace(request.SearchTerm) &amp;&amp;<br>    request.SearchTerm.Length &lt; definition.MinimumSearchLength)<br>{<br>    return new LocatorResult<br>    {<br>        Status = LocatorResultStatus.InvalidRequest,<br>        Message = &quot;The search term is too short.&quot;<br>    };<br>}</pre><p>The limit lives in the definition. The check happens at runtime.</p><h3>Read Definition</h3><p>The engine reads:</p><pre>Source<br>KeyField<br>SearchFields<br>ResultFields<br>Policies</pre><p>The definition provides materials and rules. The engine decides how to use them.</p><h3>Apply Context</h3><p>The context may select connection, company, tenant, language, or permissions.</p><p>The same definition can execute differently per context.</p><h3>Resolve</h3><p>This is the provider-specific part.</p><p>In a SQL engine, a query is produced.</p><p>In a service engine, a service call is made.</p><p>In an object engine, a collection is searched.</p><p>The result of this step is raw resolved data.</p><h3>Produce Canonical Identity</h3><p>The Locator targets canonical identity.</p><p>KeyField declares which field plays that role.</p><pre>KeyField = Id</pre><p>The user may have typed a code or name. The system ultimately wants Id.</p><h3>Produce Projection</h3><p>Often the caller needs additional fields:</p><pre>Id<br>Code<br>Name<br>TaxNumber<br>PaymentTermId</pre><p>ResultFields define that projection.</p><p>The projection belongs to the result.</p><p>Applying those fields to a target row or target object is the job of another component, usually a mapper.</p><h3>Determine Result State</h3><p>The engine decides the status.</p><p>Example:</p><pre>if (count == 0)<br>    status = LocatorResultStatus.NoResult;<br>else if (count == 1)<br>    status = LocatorResultStatus.SingleResult;<br>else if (count &gt; definition.MaximumResultCount)<br>    status = LocatorResultStatus.TooManyResults;<br>else<br>    status = LocatorResultStatus.MultipleResults;</pre><p>The result state drives the UI and the workflow.</p><h3>Return Result</h3><p>The result returns:</p><pre>Status<br>Message<br>Data<br>Count</pre><p>Data may be a table, DTO list, object list, or another container. That is an implementation concern.</p><h3>11. SQL-based engine</h3><p>In many business applications the first engine will be SQL-based.</p><p>That is practical, while the architecture remains provider-neutral.</p><p>For a SQL engine, Source may be a table:</p><p>or a select:</p><pre>select Id, Code, Name from Customer where IsActive = 1</pre><p>A SELECT as source is a convenience of the SQL implementation. It fits because SQL is a declarative language. It describes a result, not imperative steps.</p><p>Other engines will interpret Source differently.</p><p>The shared contract stays stable.</p><h3>12. Declarative policies</h3><p>Policies belong to the definition:</p><pre>MinimumSearchLength<br>MaximumResultCount<br>OrderBy</pre><p>The engine applies them.</p><p>MinimumSearchLength protects against overly short searches.</p><p>MaximumResultCount protects the UI and backend from oversized result sets.</p><p>OrderBy determines presentation.</p><p>The definition declares. The engine executes.</p><p>That is the essence of the runtime model.</p><h3>13. Resolution states in practice</h3><p>The states deserve special attention because they directly affect the UI.</p><h3>NoResult</h3><p>The request executed and the search returned an empty result.</p><p>The UI may show a message, clear the field, or suggest creating a new record.</p><h3>SingleResult</h3><p>The reference was resolved cleanly.</p><p>The caller receives canonical identity and result fields.</p><h3>MultipleResults</h3><p>There are multiple records, but the count is manageable.</p><p>The UI shows choices.</p><p>Example:</p><pre>SearchTerm = John<br>Result count = 5</pre><h3>TooManyResults</h3><p>There are many records and the search is too broad.</p><p>Example:</p><pre>SearchTerm = s<br>Result count = 500<br>MaximumResultCount = 50</pre><p>The UI asks for more specific input.</p><p>The distinction from MultipleResults is critical:</p><pre>MultipleResults<br>    show choices<br><br>TooManyResults<br>    ask for narrower search</pre><h3>InvalidRequest</h3><p>The input is invalid.</p><p>Examples:</p><pre>Search term too short<br>Unknown search field<br>Missing required input<br>Invalid key value type</pre><h3>InvalidContext</h3><p>The context is missing, incomplete, or incompatible with execution.</p><p>Examples:</p><pre>Missing company<br>Missing tenant<br>Invalid connection<br>Insufficient permissions<br>Unsupported language context</pre><h3>Error</h3><p>A technical or unexpected failure.</p><p>Examples:</p><pre>Database error<br>Service unavailable<br>Timeout<br>Serialization error<br>Unexpected exception</pre><p>Business states and technical errors should stay separate.</p><h3>14. Extensibility</h3><p>Extensibility comes from the boundaries.</p><p>The definition is declarative.</p><p>The request is runtime input.</p><p>The context is runtime environment.</p><p>The result is outcome.</p><p>The engine is interpreter.</p><p>With these boundaries, we can have many engines:</p><pre>SqlLocator<br>ServiceLocator<br>ObjectLocator<br>CacheLocator<br>DirectoryLocator<br>GraphLocator</pre><p>All of them implement the same basic contract:</p><pre>public abstract class Locator<br>{<br>    public abstract LocatorResult Execute(<br>        LocatorDefinition definition,<br>        LocatorRequest request);<br>}</pre><p>The application continues to call Locators.Execute(request).</p><p>The engine change happens behind the definition.</p><p>This is practical extensibility. The caller stays free of if/else logic for every provider.</p><h3>15. Mapper: a neighboring component</h3><p>When the user selects a record, more than one field is often updated.</p><p>Example:</p><pre>CustomerId<br>CustomerCode<br>CustomerName<br>PaymentTermId<br>VatRegimeId</pre><p>The Locator answers:</p><pre>Which record corresponds to this reference?</pre><p>The Mapper answers:</p><pre>How are the result fields written to the consumer?</pre><p>The Mapper consumes LocatorResult. It is a neighboring mechanism, outside the Locator core.</p><p>It deserves a separate article because it has its own concerns: field mapping, target object, target row, validation, overwrite policy, and transactional behavior.</p><h3>16. Result materialization</h3><p>The Data of the result is an implementation detail.</p><p>In a SQL engine it may be a table.</p><p>In a service engine it may be a DTO list.</p><p>In an object engine it may be an object list.</p><p>The contract asks for:</p><pre>Status<br>Message<br>Data<br>Count</pre><p>The container is selected by the implementation.</p><p>This keeps the pattern clean.</p><h3>17. Conclusion</h3><p>The Locator starts from a practical business problem: how a user reference becomes a stable business identity.</p><p>The solution needs more than a search function.</p><p>It needs a runtime contract:</p><pre>LocatorDefinition<br>        ↓<br>LocatorRequest<br>        ↓<br>LocatorContext<br>        ↓<br>LocatorEngine<br>        ↓<br>LocatorResult</pre><p>The definition declares.</p><p>The request asks.</p><p>The context carries runtime conditions.</p><p>The engine interprets and executes.</p><p>The result returns outcome and data.</p><p>This model gives clear boundaries:</p><ul><li>The UI sends a request and reads a result.</li><li>The registry finds the definition.</li><li>The factory creates an engine.</li><li>The engine applies policies and provider-specific logic.</li><li>The result says what happened.</li></ul><p>The same grammar appears in many parts of a business application framework:</p><pre>Problem<br>        ↓<br>Architectural Concept<br>        ↓<br>Declarative Definition<br>        ↓<br>Executable Runtime Model<br>        ↓<br>Concrete Implementation</pre><p>The Locator is a good example because it is small, useful, and complex enough to show the pattern clearly.</p><p>A Locator is only one example. The important idea is the transformation itself: a declarative description becomes an executable runtime model. Once that pattern is established, the same architecture can be applied to forms, reports, workflows, validation rules, document handlers, and many other business components. The Locator simply provides a compact case study of a much broader architectural principle.</p><p>In the end, the goal is something larger than another helper class: a mechanism that can be reused, extended, and integrated into different UIs, data sources, and business workflows.</p><p><em>Originally published at </em><a href="https://teonotebook.wordpress.com/2026/07/07/fundamental-concepts-of-business-applications-iv-building-a-locator/"><em>http://teonotebook.wordpress.com</em></a><em> on July 7, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9477b70d7a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fundamental Concepts of Business Applications III: Locator Definitions]]></title>
            <link>https://medium.com/@teo.bebekis/fundamental-concepts-of-business-applications-iii-locator-definitions-72b41811837b?source=rss-48fe592c1753------2</link>
            <guid isPermaLink="false">https://medium.com/p/72b41811837b</guid>
            <dc:creator><![CDATA[Teo Bebekis]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 09:28:15 GMT</pubDate>
            <atom:updated>2026-07-06T09:41:39.516Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/440/0*E3ShWUAF5NbJwXoi" /></figure><p>In the previous article, we argued that a Locator is neither a UI control nor a search mechanism. It is an architectural concept that resolves business references within a specific business context and transforms them into canonical business identities.</p><p>If that is true, however, an obvious question immediately follows.</p><p><strong>How can a Locator be described?</strong></p><p>Not how it is implemented.</p><p>Not how it is executed.</p><p>But how it can be described independently of any particular implementation.</p><p>This question is more important than it may seem at first glance. If two different development teams decide to implement a Locator, how can they be sure they are implementing the same concept? How can we discuss a Locator without referring to a particular library, programming language, or framework?</p><p>The answer is that, like any mature architectural concept, a Locator must first be separated from its implementation.</p><p>This distinction appears repeatedly throughout the history of software engineering.</p><p>Relational theory existed before relational database systems.</p><p>SQL does not describe <em>how</em> a query will be executed. It describes only the result we want to obtain. The choice of indexes, execution plans, and optimization algorithms is the responsibility of the query optimizer.</p><p>Exactly the same principle applies here.</p><p>A Locator should not be defined by the mechanism that implements it.</p><p>It should be possible to describe it independently of that mechanism.</p><p>This naturally leads to three distinct levels of abstraction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/1*_BDU25JApX2Se8toYdNm6w.png" /></figure><p>The <strong>Locator Pattern</strong> is the architectural concept itself.</p><p>The <strong>Locator Definition</strong> is the declarative description of a particular resolution process.</p><p>The <strong>Execution Engine</strong> is the component responsible for interpreting that description and performing the actual resolution.</p><p>Each level has a different responsibility, and they should never be confused with one another.</p><p>This means that a <strong>Locator Definition</strong> is not an implementation artifact. It is neither a class, an API, a SQL query, nor a UI component.</p><p>It is a <strong>declarative description</strong> of a business reference resolution process.</p><p>Or, if you prefer, it is the contract that defines what it means to resolve a particular business reference without describing how that resolution should be performed.</p><p>This naturally leads to the next question.</p><p><strong>What is the minimum amount of information required to describe a Locator completely?</strong></p><p>The answer is that every Locator Definition must answer a small number of fundamental questions.</p><h3>1. What can be resolved?</h3><p>Which business entity is being resolved?</p><p>A Product?</p><p>A Customer?</p><p>A Warehouse?</p><p>An Account?</p><p>Notice that we are not talking about database tables or object-oriented classes.</p><p>We are talking about business concepts.</p><h3>2. How can it be referenced?</h3><p>How can users refer to that entity?</p><p>By code?</p><p>By name?</p><p>By barcode?</p><p>By registration number?</p><p>By account number?</p><p>These references represent the user’s language rather than the internal language of the information system.</p><h3>3. Under which business context?</h3><p>The same business reference may represent different entities depending on the business context in which the resolution takes place.</p><p>The company.</p><p>The warehouse.</p><p>The customer.</p><p>The transaction date.</p><p>The active price list.</p><p>The actual values of this context belong to runtime. A Locator Definition does not contain those values. It merely describes that the resolution process may depend on them.</p><h3>4. What is the canonical result?</h3><p>If the resolution succeeds, what is the canonical business identity that is produced?</p><p>From that point onward, the rest of the application can safely use this identity without knowing how it was obtained.</p><h3>5. What information becomes available after successful resolution?</h3><p>Successful resolution produces more than a business identity.</p><p>It also makes available the information required for the business process to continue.</p><p>For example, resolving a product may also provide its description, unit of measure, VAT rate, or any other information required by the current business process.</p><p>The important point is that a Locator Definition does not describe specific fields. Instead, it defines the contract of the information that becomes available after a successful resolution.</p><p>Optionally, a Locator Definition may also describe the abstract source from which entities are resolved. That source is not necessarily a relational database. It may be a service, an object collection, or any other provider capable of participating in the resolution process. Even this information remains part of the description rather than the implementation.</p><p>It is equally important to understand the boundaries of a Locator Definition.</p><p>Its purpose is not to describe the technical details of execution. It does not define SQL, indexes, execution plans, caching strategies, or search algorithms. Nor does it dictate dialogs, combo boxes, grid controls, or any other user interface elements.</p><p>Those are the responsibility of the <strong>Execution Engine</strong>, which is free to choose the most appropriate implementation as long as it honors the contract defined by the Locator Definition.</p><p>In this sense, a Locator Definition resembles a small declarative language more than it resembles a class or an API.</p><p>It does not describe objects, algorithms, or implementations.</p><p>It describes a business intent.</p><p>It answers only one question:</p><blockquote><strong><em>What does it mean to resolve this business reference?</em></strong></blockquote><p>Everything else is the responsibility of the mechanism that interprets and executes that description.</p><p>So far, we have not written a single line of code.</p><p>And yet, we have already defined an architectural concept, the language used to describe it, and the information that such a description must contain.</p><p>This is perhaps the most important characteristic of a declarative architecture. The concept comes first. The description remains stable, while the mechanism that executes it may evolve, be replaced, or be completely redesigned without changing the concept itself.</p><p>The next natural question is therefore no longer <strong>what</strong> a Locator is, nor <strong>how</strong> it is described, but <strong>how such a declarative description can be transformed into a real, working software component</strong>.</p><p>That is the software engineering problem we will explore in the next article.</p><p><strong>Fundamental Concepts of Business Applications IV: Building a Locator</strong></p><p><em>Originally published at </em><a href="https://teonotebook.wordpress.com/2026/07/06/fundamental-concepts-of-business-applications-iii-locator-definitions/"><em>http://teonotebook.wordpress.com</em></a><em> on July 6, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72b41811837b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fundamental Concepts of Business Applications II: The Locator Pattern]]></title>
            <link>https://medium.com/@teo.bebekis/fundamental-concepts-of-business-applications-ii-the-locator-pattern-2ca819d0264c?source=rss-48fe592c1753------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ca819d0264c</guid>
            <dc:creator><![CDATA[Teo Bebekis]]></dc:creator>
            <pubDate>Sat, 04 Jul 2026 10:51:50 GMT</pubDate>
            <atom:updated>2026-07-04T10:57:56.277Z</atom:updated>
            <content:encoded><![CDATA[<p>In the previous article, we argued that a ComboBox is not enough.</p><p>Not because there is anything wrong with the control itself, but because the problem it is designed to solve is much smaller than the actual problem faced by a business application.</p><p>That, however, is where we stopped.</p><p>We did not answer the next question.</p><p><strong>If the problem is not selecting a value, then what exactly is it?</strong></p><p>Let us put frameworks aside for a moment.</p><p>Forget about controls.</p><p>Forget even the word <em>Locator</em>.</p><p>Imagine we are editing a line in a sales order.</p><p>The user moves to the product field and types:</p><p><strong>PROD-001</strong></p><p>What should happen next?</p><p>The first answer seems obvious.</p><p>“The product should be found.”</p><p>Agreed.</p><p>But is that really enough?</p><p>Let us assume the product has been found.</p><p>Are we finished?</p><p>Not at all.</p><p>The application still does not know which sales price applies, which unit of measure should be used, which VAT rate is applicable, or even whether the item is currently available in stock.</p><p>And in many cases, it must know even more.</p><p>Perhaps a different pricing policy applies to this particular customer.</p><p>Perhaps a different price list is currently active.</p><p>Perhaps even the document date changes the result.</p><p>This leads to the first truly interesting question.</p><p><strong>Where does all this information come from?</strong></p><p>Suddenly, the product is no longer simply the product.</p><p>It is the same product <strong>within a specific business context</strong>.</p><p>And that context is not an implementation detail.</p><p>It is not an internal state maintained by whatever mechanism performs the resolution.</p><p>It is an explicit input to the problem itself.</p><p>There is another important observation.</p><p>The user did not enter a ProductId.</p><p>They did not enter a GUID.</p><p>In fact, they are probably unaware that such an identifier even exists.</p><p>They entered:</p><p><strong>PROD-001</strong></p><p>In other words, they entered a business reference.</p><p>This is perfectly natural.</p><p>People do not think in terms of technical identifiers.</p><p>They think in product codes.</p><p>Names.</p><p>Barcodes.</p><p>Account numbers.</p><p>Concepts that carry meaning within the business itself.</p><p>That is their language.</p><p>The information system, however, operates differently.</p><p>Its relationships rely on unique, stable identities.</p><p>Primary keys.</p><p>GUIDs.</p><p>Surrogate keys.</p><p>Someone must therefore translate the language of the user into the language of the system.</p><p>And that translation must be correct.</p><p>Within the appropriate business context.</p><p>Up to this point, one could argue that we are simply describing a search.</p><p>I would probably agree.</p><p>At least until the first real business scenario appears.</p><p>Because a search merely returns results.</p><p>Here, however, we are not simply searching.</p><p>We are trying to answer a much more specific question.</p><p><strong>Which business entity does the user actually mean?</strong></p><p>That is a fundamentally different question.</p><p>It is not about discovering information.</p><p>It is about <strong>resolving a business reference</strong>.</p><p>Let us now give names to the individual steps of this process.</p><p>The user provides a business reference.</p><p>The application evaluates it within the current business context.</p><p>It attempts to resolve it.</p><p>It arrives at a canonical business identity.</p><p>Finally, it returns the information required for the task to continue.</p><p>Conceptually, the process looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/558/1*_Qu2bb91CmLe_MVf1ECW2A.png" /></figure><p>Notice something interesting.</p><p>There is no ComboBox.</p><p>No Grid.</p><p>No Dialog.</p><p>In fact, there is no user interface at all.</p><p>There is only a process.</p><p>That process does not always produce the same outcome.</p><p>It may find no matching entity.</p><p>It may find exactly one.</p><p>It may find a small number of possible candidates.</p><p>Or it may find so many that the result is no longer useful.</p><p>The last case deserves special attention.</p><p>If the system returns five products, we are dealing with normal business ambiguity.</p><p>The user can easily choose the correct one.</p><p>If, however, it returns five thousand products, we are no longer dealing with ambiguity.</p><p>We are dealing with a business reference that is simply too broad to be resolved.</p><p>The problem is not the list.</p><p>The problem is the reference itself.</p><p>The application should not ask the user to choose one product out of five thousand.</p><p>It should ask for a better business reference.</p><p>This distinction is fundamental.</p><p>Business ambiguity and resolution failure are not the same thing.</p><p>The more closely we examine this process, the harder it becomes to view it as just another UI control.</p><p>The same process can be used by a desktop application.</p><p>A web application.</p><p>A service.</p><p>A data import process.</p><p>An automated workflow.</p><p>The interaction changes.</p><p>The resolution process does not.</p><p>And when the same concept appears in exactly the same form regardless of the application type or user interface, it stops looking like a UI detail and starts looking like an architectural concept.</p><p>Perhaps this is the real meaning of the word <strong>Locator</strong>.</p><p>Not as a control.</p><p>Not as a search mechanism.</p><p>But as the name of an architectural concept.</p><p>A concept with one-and only one-purpose:</p><p>To transform human business references into canonical business identities within a specific business context.</p><p>This is what, in this article, we call <strong>The Locator Pattern</strong>.</p><p>If the Locator is indeed an architectural pattern, another question immediately follows.</p><p>How should it be described?</p><p>What is the minimum information required to define a Locator?</p><p>How can that description remain independent of the mechanism that executes it?</p><p>In other words,</p><p><strong>Can a Locator be defined declaratively?</strong></p><p>That is precisely what we will examine in the next article.</p><p><strong>Fundamental Concepts of Business Applications III: Locator Definitions</strong></p><h3>Closing Question</h3><p>Does this concept already exist, perhaps under a different name, in the framework or platform you use?</p><p>If so, I would genuinely like to learn about it.</p><p><em>Originally published at </em><a href="https://teonotebook.wordpress.com/2026/07/04/fundamental-concepts-of-business-applications-ii-the-locator-pattern/"><em>http://teonotebook.wordpress.com</em></a><em> on July 4, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ca819d0264c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fundamental Concepts of Business Applications I: Why a ComboBox Is Not Enough]]></title>
            <link>https://medium.com/@teo.bebekis/fundamental-concepts-of-business-applications-i-why-a-combobox-is-not-enough-d0c086548a46?source=rss-48fe592c1753------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0c086548a46</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[enterprise-software]]></category>
            <category><![CDATA[software-design]]></category>
            <dc:creator><![CDATA[Teo Bebekis]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 11:28:29 GMT</pubDate>
            <atom:updated>2026-07-03T12:23:41.000Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introducing the Locator</h3><p>If you have developed even a single business application, chances are you have solved the same problem many times.</p><p>You have built a customer search dialog.</p><p>You have implemented product autocomplete.</p><p>You have written a custom editor for a data grid.</p><p>You have created a selection popup.</p><p>Every time, you were essentially solving the same problem.</p><p>Yet most UI libraries do not treat this requirement as a distinct concept. It usually appears as a lookup, an autocomplete, a popup dialog, or some other widget. The implementation changes, but the underlying problem remains exactly the same.</p><p>In this article, I would like to suggest that this recurring requirement deserves to be recognized as a fundamental concept of business applications. I will call it a <strong>Locator</strong>.</p><h3>A Problem Found in Every Business Application</h3><p>Almost every business application contains fields that reference other business entities.</p><p>A sales order references a customer.</p><p>An invoice references a supplier.</p><p>A warehouse transaction references a product.</p><p>A journal entry references an account.</p><p>In the database, these relationships are stored as stable identifiers. Users, however, never think in terms of CustomerId or ProductId. They think in terms of customer codes, names, tax numbers, barcodes, and other business identifiers that are meaningful to them.</p><p>The real problem is therefore not how to store an identifier.</p><p>The real problem is how users can locate the correct business entity using the information they already know.</p><h3>Why a ComboBox Is Not Enough</h3><p>When the dataset is small, a ComboBox is an excellent solution.</p><p>Countries.</p><p>Currencies.</p><p>Units of Measure.</p><p>Payment Methods.</p><p>These are reference tables containing a few dozen or perhaps a few hundred rows. Loading them into memory is perfectly reasonable, and selecting an item from a list is both fast and convenient.</p><p>The picture changes completely when we talk about Customers, Products, Suppliers, or General Ledger Accounts. Here the number of records may reach thousands-or even hundreds of thousands.</p><p>At this point, the problem is no longer selecting an item from a list.</p><p>The problem is <strong>locating</strong> the correct record.</p><p>And that is an entirely different problem.</p><h3>The Locator</h3><p>Most UI libraries provide general-purpose controls such as TextBox, ComboBox, ListBox, DataGrid, and TreeView.</p><p>Business applications, however, need something different.</p><p>They need a mechanism that allows users to locate a business entity using the information they naturally recognize, rather than its technical identifier.</p><p>This mechanism is what I call a <strong>Locator</strong>.</p><p>Its purpose is not to display a list.</p><p>Its purpose is not to suggest possible values.</p><p>Its purpose is to <strong>resolve a business reference</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*4WNcCNVJdrXLBniZ" /></figure><h3>A Locator Does Not Simply Return a Value</h3><p>At first glance, a Locator may look like an advanced lookup control or an autocomplete widget.</p><p>In reality, it does something far more important.</p><p>It does not simply return a value.</p><p>It resolves a business reference.</p><p>Consider a sales order line containing a ProductId field.</p><p>The user searches for a product by typing its code or description.</p><p>Once the correct product has been selected, the application usually needs much more than the ProductId.</p><p>It may need the unit price.</p><p>The unit of measure.</p><p>The VAT rate.</p><p>The discount category.</p><p>It may even need different information depending on the customer, the company, the warehouse, or any other business context in which the search takes place.</p><p>A Locator therefore does not simply return a value.</p><p>It returns the result of resolving a business reference within a specific business context.</p><p>That is why it is much more than an advanced lookup control.</p><h3>It Is Not a Control. It Is a Behavior.</h3><p>This is perhaps the most important idea.</p><p>A Locator is not a particular user interface control.</p><p>It is a behavior.</p><p>In a desktop form, it may appear as two searchable fields.</p><p>In a data grid, it may be implemented as a custom cell editor.</p><p>In a web application, it may appear as an autocomplete field with a popup results list.</p><p>In a mobile application, it may open a dedicated search screen.</p><p>The appearance changes.</p><p>The behavior remains exactly the same.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*B0KARv_GOm-gW6z_1ZYuHw.png" /></figure><h3>The User Experience</h3><p>Experienced business application users work almost entirely with the keyboard.</p><p>A good Locator should never interrupt that workflow.</p><p>When a search produces a unique match, the selection should be completed immediately.</p><p>Only when multiple possible matches exist should the user be asked to choose the correct business entity.</p><p>A Locator is not only about searching.</p><p>It is also about disambiguation.</p><h3>Why Every UI Library Should Include a Locator</h3><p>Every serious business application solves this problem every day.</p><p>Yet most UI libraries do not recognize it as a fundamental abstraction.</p><p>Instead, every application ends up implementing search dialogs, autocomplete controls, custom editors, and selection popups over and over again.</p><p>The functionality is essentially the same.</p><p>Only the implementation differs.</p><p>I believe that the Locator represents a fundamental concept of business applications, one that is still treated primarily as a collection of unrelated UI widgets.</p><p>Perhaps it is time to recognize it for what it really is: a fundamental abstraction for building data-entry and business applications.</p><p>Because in business applications, the critical concept is not displaying a list.</p><p>It is enabling users to locate the correct business reference.</p><p>In the next article, I will leave philosophy behind and move on to architecture.</p><p>What information should a Locator know?</p><p>How should it be described?</p><p>And how can the same definition be reused across forms, data grids, and different user interface technologies?</p><p><em>Originally published at </em><a href="https://teonotebook.wordpress.com/2026/07/03/fundamental-concepts-of-business-applications-i-why-a-combobox-is-not-enough/"><em>http://teonotebook.wordpress.com</em></a><em> on July 3, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0c086548a46" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>