Skip to main content
Field notes / philosophy

Custom software stopped being expensive

Packaged software exists because custom software was expensive to write and worse to maintain. When an agent writes, tests, releases and maintains a system on a platform that already holds your data and access rules, that cost collapses, and the question at each renewal changes from which product to whether you still need a product. Which workloads move first, what your agent builds in their place, and what stays.

11-minute readPhilosophy

Why packaged software won

Every company would prefer software that fits it exactly: its own stages in the pipeline, its own approval rules, its own words on every screen. For forty years almost nobody could afford that. Custom software was expensive to write, more expensive to connect to everything else, and most expensive of all to keep alive after the people who wrote it left.

So companies bought. A packaged product is one vendor’s guess at what the average customer needs, sold to thousands of customers so that the cost of writing it is shared. The bargain was sound. You accepted a product that fit your business most of the way, bent your process to cover the rest, and in exchange you did not employ a software team for the returns desk.

Ronald Coase described the logic in 1937, long before software. A firm does a thing itself when doing it internally costs less than buying it, and buys it when the market is cheaper. The boundary between the two is set by cost, and it moves when the costs move. For business software the cost of making was so high for so long that the boundary sat far out: companies bought nearly everything, including tools for jobs that were unique to them.

The cost of making collapsed

Look at where the cost of custom software actually was. Writing the code was the visible part and never the largest. The larger parts were connecting it to the company’s data, testing it, shipping it safely, securing it, and keeping it running and changing for years.

An agent on Plexara removes each of those costs by a specific mechanism. A frontier model (Claude, ChatGPT, Gemini, and the ones that replace them) writes the system from a conversation with the person who needs it. The data is already connected, with its definitions, so there is no integration project. Tests are written with the code and required before a version can be saved. Shipping is a release an admin approves with the changes in view, and going back is a rollback. Sign-in, access rules and the record of every call come from the platform. Deasil runs the platform, and the agent maintains the application: it reads the run record, proposes the fix and tests it against earlier runs.

This is the difference between an agent writing code and an agent writing code on a platform. Code alone was never the problem. The seven costs in the table below were, and they are the reason the platform has to be built for the agent.

Where the cost of custom software went

CostCustom software, as it wasAn application on Plexara
Writing itDevelopers, for weeks or months, from a specification someone else wroteAn agent, from a conversation with the person who needs it
Connecting it to your dataAn integration project for each systemAlready connected: the warehouse, the catalog and every API connection your team has set up
Testing itA test suite people write and maintain, or noneTests written with the code, run on a throwaway copy of the database on every save, and required before a version can be saved
Shipping itA pipeline, an environment and someone who understands bothA release an admin approves, with the diagram and the list of changes in view
Securing itA login, roles and an audit trail built into each applicationYour identity provider, your existing access rules and the platform’s record of every call
Keeping it runningThe developers who wrote it, for as long as they stayDeasil runs the platform. The agent reads the run record, proposes the fix and tests it against earlier runs.
Changing it next yearA new project, often a rewriteA request. The change ships as the next release and the last one is a rollback away.
Packaged software won because every row in the middle column was expensive. Each row on the right is a capability that shipped on Plexara this year.

The renewal question changes

When the cost of making falls this far, Coase’s boundary moves, and it moves toward the firm. A long list of software that was obviously cheaper to buy is now cheaper to have built, built to fit exactly, and owned.

The practical effect lands on one meeting: the renewal. For years the renewal conversation had one question, which product. Keep this vendor, switch to that one, negotiate the seats. There is now a prior question: do we still need a product for this? For a system of record the answer is yes and the conversation continues as before. For a large number of the tools bought around those systems, the answer is that the company needed an outcome, bought a product because that was the only way to get it, and now has another way.

Our clients are having this conversation across departments. One move is already published: an Apache NiFi installation of about 2,000 processors, the kind of flow-canvas system companies adopt after outgrowing a recipe tool, replaced by automations an agent wrote and now maintains. It was retired one flow at a time, and a flow was switched off only after a recorded comparison showed the new output matched the old. The account is in retiring an integration platform one flow at a time. The method is the lesson: no product was replaced in one decision. Each flow was a small question with a clear answer.

Which workloads move first

The workloads that move first share three traits: they sit around a system of record instead of being one, the people who use them have a backlog of requests the vendor never met, and their data already flows through systems Plexara connects to. What people build with coding agents in practice matches this. SaaStr’s account of the field is that people build the tools around their systems of record, and a platform is what turns those builds from one person’s experiment into something the company runs.

Dashboards and reporting go early. Viewer seats are the clearest case: licences for Tableau or Power BI bought so that people can open a dashboard someone else built. An agent builds the dashboard, the map, the deck or the workbook from governed data, an automation refreshes it, and it is shared by link with the people who need it, including clients. Workflow and integration glue goes next: the Workato and Zapier recipes, billed by task or by recipe, that move a record from one system to another. Each becomes an automation with tests and a run record. Forms and intake follow, then the internal tools that live in spreadsheets and low-code builders, then the departmental and campaign sites that today are separate WordPress installs with their own plugins, hosting and agency retainer.

The last row is the boldest and it is real. The application database is transactional and built to be a system of record for an order system or a request tracker, so the customization backlog on a CRM (the custom objects, the add-on seats for people who only need one screen, the niche product bought for one team’s process) is spend to re-examine. The CRM itself stays. What changes is that the next unusual process is built beside it in a week, reading and writing it through its API, instead of being bought as another module.

The workloads that move first

WorkloadThe spend to re-examineWhat the agent builds on PlexaraLimits
Dashboards and reportingPer-seat BI licences bought so people can open a dashboard, and scheduled report subscriptionsInteractive dashboards, maps, decks, PDFs and workbooks the agent builds, refreshed by automations and shared by linkA BI team’s governed self-service modeling stays in its tool, and Plexara connects to it
Workflow and integration glueRecipes and flows on a canvas, billed by task or connectorAutomations with tests, versions and a run record, started on demand, on a schedule, once per event, or once per requestA failed run alerts its owner and is not retried automatically. A library of hundreds of prebuilt connectors is a different product.
Forms and intakeA form builder, a catch-hook service and an email parserForms the agent builds with a hosted page and encrypted sensitive fields, webhooks and a mailbox as sources, every arrival a rowNo drag-and-drop builder, conditional logic, multiple pages, payments or themes
Internal toolsSpreadsheets with macros, a low-code builder, a script on a laptopAn application with its own database, pages at its own address and releasesBuilt by describing it to an agent. There is no visual page builder.
Departmental and campaign sitesA content system install per site, with plugins, hosting and an agency retainerSites on your own domain, built in a private dev copy, promoted by a person, with layouts that generate pages from recordsSites are published files plus forms and endpoints. A marketing team that edits in a visual editor all day keeps its editor.
Order, request and tracking systemsCustomization and add-on seats on a CRM or ERP, or a niche vertical productA transactional application: tables with enforced rules, a checkout or intake in one transaction, events after commitThe CRM, the ERP and finance stay as systems of record. Forms take no payments, so payment stays with your processor.
Read each row at its renewal. The second column is the spend to question, the third is what your agent builds in its place, and the fourth is the limit to weigh before you decide.

The limits, as facts

A buying decision needs the limits stated as plainly as the capabilities. Forms have no drag-and-drop builder, no conditional logic, no multiple pages, no payments and no themes. An automation that fails alerts its owner and is not retried automatically, because it may already have written something. Plexara does not ship a library of hundreds of prebuilt connectors: your agent connects a system through its API, and a product whose whole value is that library is a different purchase. A BI team that models data for governed self-service keeps its tool, and Plexara connects to it. A site is published files with forms and endpoints behind it, built by describing it to an agent, so a team that lives in a visual page editor keeps the editor.

None of these limits touches the central point. Each one marks the edge of a workload, and inside the edge the economics have already changed.

What stays

The systems of record stay: CRM, ERP, HR, finance, the warehouse. Other systems, auditors and regulators depend on them, their vendors carry obligations you want carried, and Plexara is built to read them, write to them and build around them. The full argument is in systems of record stay.

Products that are networks stay, because their value is the other parties on them: payment processors, email delivery at scale, messaging. Deep specialist tools stay. So does anything bought for a certification your auditors require of that function.

What is left is the long tail of tools around those, and the tail is where the line items are. Most companies run a long list of them. Each was a reasonable purchase when making was expensive, and each is a candidate now.

What stays

KindExamplesWhy it stays
Systems of recordCRM, ERP, HR, finance, the warehouseOther systems, auditors and regulators depend on them. Plexara reads them, writes to them through their APIs, and builds around them.
Products that are a networkPayment processing, email delivery at scale, messaging, marketplacesTheir value is the other parties connected to them, which no application you build reproduces.
Deep specialist toolsDesign suites, engineering and scientific software, a BI team’s modeling layerDecades of domain work that the people who use them all day rely on.
Regulated certificationsA product bought because it carries a certification your auditors require for that functionThe certification is the thing being bought.
Consolidation is specific. These four kinds stay, and the tools bought around them are the lines to re-examine.

What you own afterwards

Buying software rents you a capability. When the subscription ends, the capability ends, and the data comes back as an export. Building on Plexara leaves you holding the system: the tables, the automations, the pages, the release history, and the diagram that explains how they fit, along with the knowledge your team recorded while building it.

It also ends the wait for a roadmap. Every packaged product has a list of requests its vendor declined, for good reasons: a feature for one customer is a cost to all the others. An application built for one company has no such conflict. The request a vendor would have declined is the next release, shipped the week someone asks. Over a few years this compounds into software that fits the business the way only custom software ever did, at a cost that used to buy the average.

And the builder keeps improving without your involvement. Each new frontier model connects to the same deployment and builds larger systems under the same rules. The asset you accumulate, context and working systems, is the part that does not depreciate when the model changes.

What to do at the next renewal

Pull the list of software renewals for the next two quarters and sort it with five questions. What do we actually use? Where does its data come from and go to? Is it a system of record? What did we want that it never did? Who would own it if we built it?

Pick the first candidate where the answers are a small used surface, data already on Plexara, not a system of record, a real backlog and a willing owner. Have that owner describe the outcome to an agent and ask for the first working piece as an application, with the diagram and the contents of the first release shown before anything is released. Run it beside the product until the renewal date. Then decide with both in front of you.

Do this one workload at a time. The companies that gain the most from this shift are the ones that stop treating the software budget as a fixed list of products and start treating it as a list of outcomes, each with a price for buying and, for the first time in forty years, a competitive price for making. For how this compares with canvas tools specifically, see Plexara compared with workflow automation tools.

Five questions to ask at each renewal

  1. 01

    What do we actually use?

    List the screens, reports and automations people open in a month. A packaged product is priced for everything it can do, and most teams use a small part of it.

  2. 02

    Where does its data come from and go to?

    If the answer is systems Plexara already connects to, the hard part of replacing the workload is already done.

  3. 03

    Is it a system of record?

    If other systems and auditors treat it as the source of truth for customers, money or people, it stays. Build around it.

  4. 04

    What did we want that it never did?

    Every product has a backlog of requests its vendor declined. An application built for one company has no such backlog, because the next request is the next release.

  5. 05

    Who would own it?

    An application needs an owner who can describe what it should do and an admin who releases it. If nobody will own it, keep buying.

The questions sort workloads into three groups: move now, move at the next renewal, and stays.