Building custom HubSpot modules has traditionally required a combination of HTML, HubL, CSS, JavaScript, and a good understanding of the HubSpot CMS. That is beginning to change. With AI, creating a functional starting point for a custom module can be as simple as describing what you want.
But faster development does not mean developers are becoming unnecessary. It means the relationship between marketers, developers, and technology is changing. At Computan, we have been experimenting with this shift by building an AI-powered HubSpot Module Builder that turns natural-language instructions into reusable CMS modules.
HubSpot modules are reusable components that marketers can add to website pages, landing pages, and blog posts. They can contain text, images, forms, buttons, testimonials, and other interactive elements.
The real advantage is flexibility. Instead of rebuilding the same component for every page, developers can create a reusable module that marketers can configure directly inside the content editor. [1]
However, creating custom modules has traditionally involved technical work. Developers need to define the module structure, configure its fields, write the necessary markup, and handle styling and functionality.
For example, consider a testimonial section. A marketing team might need a component with:
Although this sounds like a relatively simple component, building it as a reusable HubSpot module requires more than placing text and images on a page.
AI is changing how teams approach this work. Instead of starting with code, they can start with a description of the component they want to build.
One of the most interesting developments in AI-assisted development is the ability to translate a business requirement into a working technical starting point.
Rather than manually defining every field and writing the initial module structure, a user can describe the intended functionality and let AI help generate the component.
Imagine asking for a testimonial module with five configurable entries, each containing a headshot, company logo, customer name, designation, and testimonial text.
Instead of beginning with a blank development environment, the user describes the requirements in plain English.
AI can interpret that request and help generate the module structure, including its configurable fields and presentation.
This does not mean every requirement will be understood perfectly on the first attempt. The output still needs to be reviewed and tested. But it significantly changes how the development process can begin.
The next step is connecting the development workflow to the relevant HubSpot environment.
In Computan's internal Module Builder experiment, the process was designed to connect to a HubSpot portal and generate modules from natural-language instructions. The idea is to reduce the distance between describing a component and getting a usable starting point inside the CMS.
As Sajeel Qureshi explained during an internal discussion:
"You connect your portal, you type, give me a module, give me like a testimonial widget with five with N number of, you know, options, headshot, logo, and text box, and boom, there's your module, just like that."
That is an important shift. The user is describing the desired outcome rather than having to understand every technical step involved in creating it.
A useful custom module needs to be more than a visual element. It needs configurable fields so that content editors can change the content without modifying the underlying code.
For example, a testimonial module should allow a marketer to replace the customer photograph, update the testimonial, change the company logo, and add or remove entries without rebuilding the component.
HubSpot's module documentation explains how developers can configure fields, repeater options, display conditions, and the HTML + HubL, CSS, and JavaScript used to define module behaviour. [1][2]
AI can help generate these building blocks, making the initial creation process faster and more accessible.
The biggest change is not simply that modules can be generated faster. It is that the traditional division between describing a requirement and implementing it is becoming less rigid.
Marketing teams often know exactly what they want a page component to do. They might need a testimonial carousel, a pricing comparison, a customer logo grid, or a lead-generation section.
Historically, these requirements had to be translated into technical specifications before development could begin.
With AI-assisted development, marketers can communicate their requirements in natural language and generate an initial version of the component.
This creates a more collaborative workflow. Marketers can participate in prototyping and refinement rather than waiting for every small change to enter a development queue.
AI does not eliminate the need for technical expertise. It changes where that expertise is applied.
Developers can use AI to accelerate repetitive work, generate initial structures, and explore implementation options. They can then focus on architecture, performance, accessibility, integrations, security, and more complex functionality.
Joe Jerome highlighted this distinction during the discussion:
"Now, obviously, if you're going to build something really sophisticated, you probably want to get a developer involved."
This is an important point. Generating a module and delivering a production-ready component are two different things.
Another opportunity is the ability to test ideas earlier in a project.
Instead of spending time developing a component from scratch just to see whether an idea works, teams can generate an initial version, review it, and decide what needs improvement.
As Sajeel explained:
"You can start with all of that, I mean, and work with it."
That is perhaps the most practical way to look at AI-assisted development. It gives teams a starting point that they can improve rather than requiring every idea to begin with a full development cycle.
AI-assisted development and traditional development are not competing approaches. They can complement each other, depending on the complexity of the requirement.
| Area | Traditional development | AI-assisted development |
|---|---|---|
| Starting point | Technical requirements and code | Natural-language instructions |
| Initial structure | Created manually by developers | Can be generated with AI assistance |
| Module fields | Defined and configured manually | Can be suggested and generated from requirements |
| Prototyping | Requires development effort | Can be accelerated through AI |
| Complex functionality | Requires technical expertise | Still requires developer involvement and review |
| Quality assurance | Developer-led testing | Developer-led testing and validation remain necessary |
The difference is in how much of the repetitive initial work can be accelerated. The need for a reliable implementation does not disappear.
It is tempting to assume that if AI can generate a module from a prompt, it can handle the entire development process. That is not necessarily the case.
There are several areas where technical oversight remains important.
A basic testimonial widget is relatively straightforward. A component that involves dynamic data, external APIs, conditional rendering, or complex interactions requires more technical planning.
AI can assist with the implementation, but developers need to validate the architecture and make sure the component behaves as intended.
A module can function correctly and still look out of place on a website.
It needs to follow the website's design system, including typography, spacing, colours, responsive behaviour, and visual hierarchy.
Human designers and developers remain important in ensuring that generated components fit the broader website experience.
Generated code should not automatically be treated as production-ready.
Developers need to check how modules behave across different screen sizes, browsers, templates, and content configurations. They also need to consider accessibility, performance, and maintainability.
The objective should be to use AI to accelerate development without lowering the quality standards expected from a production website.
Reusable modules often become part of a website's underlying design system. A poorly structured component can create maintenance problems when the website evolves.
Developers need to ensure that generated modules are organized, documented, reusable, and easy to update.
At Computan, we are exploring how AI can become part of the actual development workflow rather than simply another tool used to generate code.
Our AI-powered HubSpot Module Builder is one example of that approach.
The concept is straightforward: connect a HubSpot portal, describe the module you need, and let AI help generate the component.
During our internal discussion, Joe Jerome highlighted the opportunity this creates:
"Because now anyone could build a module."
The goal is to make the starting point of custom module development more accessible while allowing developers to focus on the technical work that requires their experience.
We are also looking at how these capabilities can fit into real website projects. As Sajeel mentioned, the team plans to start using the module builder in upcoming projects, including generating modules through English-language instructions and evaluating how they perform in completed builds.
This is where the experiment becomes particularly interesting. Instead of treating AI-generated modules as standalone demonstrations, we can evaluate them within actual project requirements and improve the workflow based on what works.
Computan is also exploring other AI-powered HubSpot capabilities, including a HubSpot Audit tool that scans a portal for potential issues involving workflows, contacts, duplicates, data quality, and outdated configurations.
These experiments share a common direction: using AI to make complex HubSpot capabilities easier to access while keeping technical implementation and expertise at the centre of the process.
AI is changing how custom HubSpot modules are created. Tasks that traditionally started with writing code can now begin with a description of what a marketing team wants to build.
That creates opportunities for faster prototyping, closer collaboration between marketing and development teams, and more efficient delivery of reusable website components.
But the real opportunity is not removing developers from the process. It is giving them better tools to work with.
AI can generate the starting point. Developers bring the technical judgement, design awareness, and experience needed to turn that starting point into something reliable.
At Computan, we believe the next stage of AI-assisted development will be defined by how effectively teams combine these capabilities. The companies that get the most value will not necessarily be the ones generating the most code. They will be the ones building better workflows around it.
Yes. AI can help generate custom HubSpot modules from natural-language instructions, including initial structures and configurable fields. The resulting code still needs to be reviewed, tested, and refined before production use.
AI can reduce the amount of coding knowledge needed to get started. Users can describe the component they want in plain English. However, more advanced functionality, troubleshooting, and production-level implementation may require a HubSpot developer.
Potential use cases include testimonial widgets, customer logo sections, pricing tables, reusable content blocks, and other custom website components. The available functionality depends on the module builder and the requirements of the HubSpot portal.
No. AI can automate repetitive development tasks and accelerate initial implementation, but developers remain important for architecture, complex functionality, integrations, design consistency, security, and quality assurance.
Not automatically. Every generated module should be tested for functionality, responsiveness, accessibility, performance, and compatibility with the existing HubSpot theme and templates before being published.
Yes. AI can accelerate repetitive tasks such as generating initial module structures, suggesting fields, and creating reusable components. Combined with developer expertise, it can help teams move from requirements to implementation more efficiently.