The Internet is on fire across Reddit and LinkedIn with Salesforce’s recent announcement of Headless 360 at its TDX 2026 conference. While it’s certainly exciting to have an extendable range of APIs available to you to build off of the Salesforce platform, the concept of headless is nothing new.
As a matter of fact, Salesforce has flirted with Headless for years across Heroku, Commerce Cloud, and parts of Marketing Cloud. But just because you surface an API for a particular function…doesn’t mean that you’ve achieved a full Headless platform.
Headless requires the ability to replace the full User Interface that a company ships, in other words: you can build your own interface without much friction.
Defining “Headless”
To have a cogent discussion on this, we really need to define what headless means. Headless means we have a software architecture where the front-end (the head) is completely decoupled from the back-end logic and data storage (the body). What that means is we’re going to use a set of APIs to interact with the database, the business logic layer, and so forth to build our own UI.
What a headless experience means is that you build your own User Interface (UI).
Headless, at its very basic definition, just means you can use a piece of software however you like, with whatever UI you want. A lot of headless software out there has its own webapp that you can log into, its own curated experience, but then you can extend it into your own.
Examples in the Wild
This has been long tail for omni-channel delivery. For instance, headless CMS (Content Mangement System). You have headless CMS vendors out there, and you’ve probably visited a website powered by them: example of theseare Contentful, Sanity, and to an extent Drupal.
From an OMS (Order Management System) driving e-commerce, you have your headless commerce examples such as Salesforce. Then you have Shopify, which is the shining headless commerce examle.
All headless means, at its very basic definition, is that you’re building a bunch of back-in connective tissue and your front end, allowing you to build that own experience.
The Misconception: “No UI” vs. “Your UI”
Headless, from an architecture standpoint means that, yes, you’re returning text in a backend API, but that doesn’t mean that it’s a backend text-driven user interface and experience. Every single webapp or mobile app that you use today receives text from the backend to the fronted to consume, and the frontend is sending text to the backend service(s).
What a headless experience means is that you build your own User Interface (UI).
Even text is a user interface.
Don’t think of headless as, “Oh, well, headless isn’t for me because I’m just driving a text-based experience.” Think of headless as the ability to build your own experience for interacting with Salesforce.
Whether that is through a CLI experience, whether that is a ChatGPT or Claude experience, whether that’s an agent you’ve built, or you’ve built your own frontend web app to accommodate a different experience…that is the “head.”
Headless just means you can use the same APIs, the backend that other companies use in their frontend web apps, but with less opinionation. You’re not forced into a cookie-cutter experience that everyone else is using.
You can extend your own, whether that’s in a mobile app, a webapp, Slack app, or even a CLI if you’re feeling spunky.
Headless means we have a software architecture where the frontend (the head) is completely decoupled from the back-end logic and data storage (the body). What that means is we’re going to use a set of APIs to interact with the database, the business logic layer, and so forth to build our own UI.
A History of Headless at Salesforce
Salesforce has flirted with headless since Salesforce1 came out around 2013, driving a unified mobile experience, extended with Heroku, allowing you to connect your Postgres database directly to Salesforce. To have a first-class citizen postgres database that you could build your own application off of.
This took out the long latency API calls, created a syncable database, and allowed you to interact with your database in your webapp or mobile app without the increased latency and building your own wrappers and SDKs. You could use your preferred ORM to interact with your database and forget that you were building against Saelsforce.
While that wasn’t necessarily headless, directly, it was a long step towards it.
Then look at Commerce Cloud. Commerce has always needed to be headless. No matter what tool you’re using, you want to build your own commerce experience, and you need to have a headless platform to build those experiences, to interact with the platform, and essentially white-label it without knowing that you’re using a particular OMS or CMS even.
Why Do We Need This? (The UI Problem)
The number one complaint that Salesforce has is its not-so-great UI and UX. Tabs on tabs, lots of text, many ways to click around. Now, part of that is on Salesforce, and part of that is on us builders. A lot of builders haven’t leaned into Screen Flows to drive custom experiences, dynamic forms to surface info only when needed, or offloading fields from an object onto another to reduce complexity.
We do have the ability to create our own LWCs (Lightning Web Components) that, while not the best in the world, can greatly extend the UI and experience and customize it for your company’s needs…not the masses.
While the push for headlesss architecture is to extend AI capabilities, specifically Agetns, there’s a huge advantage for those companies who want to build their own interfaces.
For example, you can pare down Salesforce to have just a few screens in a modern webapp (or SPA) and give users the Web 2.0 experience that they’re used to. This is incredibly useful for cases such as external SDRs that you want to push into a specific function, or say for finance that doesn’t need to know all the ins and outs of Salesforce.
The Technical Reality: Guardrails and Trade-offs
When we think of headless and who can truly harness this, it’s not going to be every company. It’s going to be the companies that are relatively tech-advanced or relatively bleeding-edge who can build and maintain their own experience.
Now, most people, when they’re hearing headless, are thinking, “OK, cool, I can use generative AI and Claude or OpenAI and easily drive an experience for my reps, whether that’s to quickly create a record or to query data.”
We already have these tools in the MCP, but even within these environments, you’ll still need to put guardrails in place.
Think about all the guardrails we have in Salesforce’s UI today, these aren’t necessarily UI issues. These are data protection issues.
You’re still going to have your validation rules. You’re still going to have flows checking for the accuracy of content. You’re still going to have automations that take your input and send it elsewhere. You’re still going to have to build your own client side validations.
You’re still going to have to build on the Salesforce platform with Flow and Apex to extend it. At this point, there’s no standalone ability to drive automations unless you’re in that Salesforce UI.
The trade-off? Traditionally, that means more API calls. That’s going to be against your API call usage. That headless experience is the same as integrating with Salesforce. You’re just using a different set of APIs that are better suited to these experiences.
The Path Forward
It’s clear that Salesforce is setting up their architecture to build revenue generating features for themselves in the future…predominately linking Salesforce and Slack together. This launch gives them a twofold advantage: ability to cater to customer demands but predominately to build their own Slack revenue features.
For customers you can embed these new experiences, say, within your ERP to take an action from a finance standpoint, but none of this is really new. We’ve had these abilities to do it. We’re just receiving better tooling with more guidance and a push from the Salesforce marketing teams.
Headless is exciting. It always has been, as a backend engineer myself, this is the world we live in. But for many builders on the Salesforce platform it’s a different way of thinking, and your builders and them people on your team aren’t likely to be able to take full advantage of them (yet).
Be very careful with this tooling. Talk with folks who understand this space, who have built these things, who are perphas engineers, and have built outside of Salesforce and used headless apps elsewhere.
There’s a lot of misinformation out there and listening to it can send you into a world of hurt.
That’s why Right Sized Tech exists, to blend product engineering experience with standard GTM abilities to take advantage of these features. To show you the possible, to build out proof of concepts to extend your platforms across other channels and verticals. We’ve built these experiences before without Salesforce’s headless APIs, and we’re excited to leverage the new endpoints to build something even greater.
So that being said, what are you excited to build?