How I Added a CMS to Wix Harmony (Yes, Really)
- The Wix Wiz
- 2 days ago
- 4 min read
Wix Harmony is one of the most interesting additions to the Wix ecosystem in years. It brings an AI-first editing experience that feels radically different from traditional website builders. But there’s one major limitation developers immediately run into:
No CMS.
At least… not officially.
In this tutorial, we explored how to unlock CMS functionality inside Wix Harmony using a custom Wix app, APIs, and a bit of experimentation. The result? A functional CMS workflow complete with collections, data display elements, and even custom forms.
The Problem With Wix Harmony
Wix Harmony is designed around AI-assisted site creation. You interact with an AI assistant to generate layouts, content, and design changes, while still having access to drag-and-drop editing controls.
For simple landing pages and app-driven websites, it works well.
But compared to traditional Wix editors like Wix Studio or the classic editor, Harmony is extremely limited for developers.
Some missing features include:
No built-in CMS access
No datasets
No Velo/dev mode
No direct code extensions
No data-driven page functionality
And that becomes a huge blocker for anyone trying to build dynamic or custom systems.
Is the CMS Actually Hidden Inside Harmony?
That was the core question behind this experiment.
Since apps like Wix Stores already function inside Harmony — and those apps are powered by CMS collections behind the scenes — it strongly suggested that the CMS infrastructure already existed internally. It just wasn’t exposed in the UI.
The idea became:
What if we could “force” the CMS into existence using Wix APIs?
And surprisingly… that worked.
Using Wix APIs to Create CMS Collections
Wix provides APIs for programmatically creating data collections. Normally, you’d use these APIs through Velo or backend code. But Harmony doesn’t allow direct dev mode access.
So instead, the solution was to create a custom Wix app using the Wix CLI.
The app acts as a bridge:
The app calls the Wix CMS APIs
The APIs create collections
Harmony detects CMS structures
CMS functionality becomes available
This app essentially “activates” CMS support inside Harmony.
Installing the CMS for Harmony App
Once installed on a Harmony site, several things happen automatically:
A CMS section appears in the dashboard
Collection management becomes available
Data collections can be created
CMS-related functionality is initialized behind the scenes
This is done by adding a special “data collection extension” to the app, which automatically enables the required code infrastructure.
In other words:
Harmony technically supports CMS functionality — it’s just not exposed by default.
Building CMS-Powered Elements in Harmony
Adding collections is only half the battle.
The next challenge is displaying and interacting with CMS data.
Since Harmony doesn’t include datasets or native CMS-connected elements, custom widgets had to be built manually inside the app.
The first widget created was a simple CMS-connected table element.
Features Included
Select a collection
Choose fields to display
Render CMS data dynamically
Apply basic design settings
The workflow feels surprisingly similar to working with CMS tables in Wix Studio — just without datasets.
Creating Custom Forms in Wix Harmony
One of the most important CMS workflows is submitting data from the frontend.
To test this, additional widgets were created:
Form dataset element
Text input element
Submit button element
Together, these recreate the traditional Wix dataset architecture manually.
The process works like this:
Add a dataset widget
Connect it to a collection
Add input elements
Bind fields to collection fields
Add a submit button
Publish the site
At that point, the form can submit data directly into the CMS collection.
The Permissions Problem
The first submission attempt failed.
The reason?
The collection permissions were still restricted, meaning visitors couldn’t insert new records.
Normally, you would solve this through the CMS permissions interface in Wix.
But Harmony doesn’t expose that either.
So the app itself was expanded again to include:
Collection permission management
Insert/update permission controls
CMS access settings
After enabling “Anyone can insert,” the custom form successfully submitted data into the CMS collection.
That confirmed the entire workflow was functional.
What’s Still Missing?
Even though the CMS now works surprisingly well inside Harmony, there are still major gaps.
The biggest missing feature is:
Dynamic Pages
At the time of testing, dynamic pages were still unresolved. It’s unclear whether Harmony currently supports them internally or whether additional workarounds will be required.
Other limitations include:
Manual widget management
No native dataset UI
Limited editor integrations
Early-stage app tooling
Some unstable behaviors and bugs
Still, the experiment proved something important:
Harmony is far more extensible than it initially appears.
Why This Matters for Wix Developers
This opens up an entirely new direction for advanced Wix development.
Instead of waiting for official CMS support, developers can already begin extending Harmony through:
Custom apps
CMS-powered widgets
Data-driven interfaces
External APIs
Custom forms
AI-assisted workflows
For developers already familiar with Wix CLI and custom app development, this creates a powerful opportunity to build tooling that dramatically expands Harmony’s capabilities.
Final Thoughts
Wix Harmony is still early.
Right now, it feels optimized more for AI-generated landing pages than advanced applications. But under the surface, there are clear signs that much more is possible.
By leveraging custom apps and Wix APIs, it’s already possible to:
Enable a CMS
Create collections
Display data
Build forms
Submit data dynamically
And this is likely just the beginning.
As Harmony evolves, the combination of AI editing + developer extensibility could become one of the most powerful workflows in the Wix ecosystem.
If you’re experimenting with Harmony development, now is probably the perfect time to start pushing its boundaries.