“Can we just change that?”
It sounds like a small request.
Update the headline. Add a section to the landing page. Change the form. Swap out an offer. Build a page for a new campaign.
Then the questions start.
Does this template support that? Do we need a developer? Will changing it affect another page? Who owns the form integration? Does analytics need to be updated? When can QA look at it? Is this part of the next release?
A change that sounded like an afternoon of work becomes a ticket, a meeting, three handoffs, and a launch date several weeks away.
At some point, it’s worth asking whether the problem is really that your team moves too slowly.
Maybe your website makes change too hard.
Website performance is usually discussed in terms of what visitors experience: page speed, load time, responsiveness, usability. Those things matter.
But there’s another kind of website performance that gets far less attention: how easily your organization can change the website when there’s a good reason to.
That matters because websites don’t operate in a stable environment. Campaigns change. Products evolve. Customers ask new questions. Search behavior shifts. Teams learn things. New opportunities appear.
And every time responding to one of those changes requires your team to fight the website underneath it, there’s a cost.
Sometimes that cost is surprisingly literal. McKinsey estimates that companies can spend an additional 10% to 20% on top of project costs addressing technical debt, the accumulated technology issues that make future development more difficult. Technical debt isn’t the only reason website changes become slow, but it’s a good example of how decisions made over time can quietly make every future decision more expensive.
The friction can also come from somewhere else entirely.
Maybe the CMS is too rigid. Maybe the website has accumulated one-off templates and integrations nobody wants to touch. Maybe routine marketing changes require development because the right components were never created. Maybe ownership isn’t clear. Maybe every request moves through an approval process designed for changes far riskier than the one you’re trying to make.
Or maybe no one is quite sure what will happen if they touch something.
At Anala, we don’t think a website is truly flexible just because it’s technically capable of changing. It needs to make the right kinds of change reasonably easy, safe, and repeatable.
That doesn’t mean marketers should be able to change anything they want without guardrails. And it doesn’t mean every slow request is evidence that you need a new CMS, a rebuild, or a major technology project.
It means the amount of effort required to make a routine change can tell you something important about the health of the system behind your website.
If a small change consistently creates a big project, it’s worth understanding why.
1. Small Changes Reveal Big Friction
Big website projects are supposed to take time.
A redesign has dependencies. A new ecommerce experience needs careful planning. A major integration should involve development, testing, security, and QA.
Nobody is surprised when complicated work is complicated.
The more interesting signal is what happens when the request shouldn’t be complicated.
Maybe marketing wants to add a new proof point to a service page. A campaign needs a landing page that follows an existing layout. Someone wants to change the order of two sections. A team needs to update a form without changing what happens after submission.
On a flexible website, those requests may still require thought and review. But the amount of work should generally make sense for the size and risk of the change.
When it doesn’t, you’ve learned something.
Pay Attention to Disproportionate Effort
Imagine your team wants to add a customer testimonial to several important pages.
The request itself is straightforward. But the existing page templates don’t have a component for testimonials, so design needs to determine how it should look. Development needs to build it. Someone needs to decide whether the new component works across every template. QA needs to test it. Then the team discovers that one group of pages was built differently three years ago and needs its own solution.
None of those individual steps is necessarily unreasonable.
The problem is the mismatch between the change being requested and the machinery required to make it happen.
That’s the kind of friction worth noticing.
If every new landing page requires development, if changing navigation creates anxiety, or if adding a content module means creating another one-off solution, the individual request probably isn’t the whole problem.
Small changes have a way of exposing the decisions, dependencies, and workarounds that have accumulated underneath the website.
Workarounds Have a Way of Becoming the System
Most website friction doesn’t appear all at once.
A team needs something quickly, so a developer creates a custom solution. A new tool gets connected for one campaign. A template is duplicated because modifying the original would take too long. Someone finds a workaround for a CMS limitation. Another team creates its own process because the existing one doesn’t fit what they need.
Individually, those decisions may be completely reasonable.
But websites remember them.
Over time, temporary fixes become permanent dependencies. Similar pages behave differently. Components that look the same aren’t actually built the same way. Teams stop knowing which parts of the website are reusable and which require special handling.
Eventually, the organization isn’t just managing the website it originally built. It’s managing years of decisions layered on top of it.
That complexity isn’t always visible to the customer.
Your homepage can look polished while the team behind it is terrified to change the hero.
The Delay Is Data
When a website request takes longer than expected, the natural reaction is to focus on getting that request finished.
But the delay itself can tell you something.
Where did the work stop? What required an unexpected handoff? What couldn’t the team change themselves? What needed custom development? What required someone to investigate how the website worked before they could safely touch it?
If the same types of delays keep appearing, they’re no longer isolated inconveniences.
They’re evidence about how your website operates.
And that evidence matters because the next step isn’t automatically to rebuild the site, replace the CMS, or hire more developers.
First, you need to understand where the friction is actually coming from.
2. Your CMS Isn't the Only Thing Slowing You Down
When website changes are consistently difficult, it’s tempting to blame the technology.
The CMS is outdated. The platform is too restrictive. The integrations are fragile. The website needs to be rebuilt.
Sometimes that’s exactly the problem.
But replacing the technology won’t necessarily make your organization faster if the friction lives somewhere else.
A modern CMS can still sit underneath a painfully slow process. A flexible component system doesn’t help much if every change requires five approvals. And giving marketers more control won’t solve the problem if nobody feels confident making a change without involving development.
Website agility depends on more than what your technology can technically do. It depends on how the entire system around the website works.
Technology Can Create Friction
Some websites really are difficult to change because of how they’re built.
Templates may be rigid. Content may be hard-coded. Integrations may depend on custom development. Similar components may have been created multiple ways over the years. An update in one place may have unexpected consequences somewhere else.
Technical debt can make all of this worse. Each shortcut, outdated dependency, or one-off solution adds another consideration to future work.
Eventually, even routine changes require someone who knows the history of the website well enough to navigate it.
That’s a technology problem.
But it’s only one kind.
Process Can Turn Small Work Into Big Work
Sometimes making the change is easy.
Getting the change through the organization isn’t.
A request enters a queue. Someone reviews it. Another person needs to clarify it. Design weighs in. Development schedules it. Analytics needs to confirm tracking. QA tests it. Someone approves the final version.
For certain changes, every one of those steps may be appropriate.
The problem comes when the process doesn’t adjust to the risk or complexity of the request.
Changing regulated content shouldn’t necessarily follow the same path as fixing a typo. Launching a new customer journey isn’t the same as swapping an image. Adding a new integration carries different risk than updating an existing content block.
If everything follows the most complicated path, routine work becomes unnecessarily expensive.
Governance Can Create Its Own Bottleneck
Governance is supposed to create clarity.
Who owns the website? Who can publish? Who approves changes? What standards need to be followed? Which decisions belong to marketing, design, development, legal, or another team?
When those answers are clear, governance can make a team faster.
When they’re not, it does the opposite.
Requests bounce between teams. People wait for approvals they may not actually need. Multiple stakeholders weigh in because nobody is sure who has the final decision. Teams create their own workarounds because the official process takes too long.
The answer isn’t eliminating governance.
It’s making sure governance creates guardrails instead of gates.
Sometimes the Real Problem Is Confidence
There’s another source of website friction that’s harder to see.
Nobody wants to touch it.
Maybe the person who originally built an integration is gone. Documentation is incomplete. The staging environment isn’t reliable. Tracking has broken after previous releases. Nobody knows whether changing one component will affect twenty other pages.
Technically, the team may have permission to make the change.
Practically, nobody feels safe doing it quickly.
That uncertainty creates its own process. More people get involved. More testing gets added. Routine requests are escalated to specialists. Changes are delayed until someone has enough time to investigate what might happen.
Sometimes the biggest source of website friction isn’t that a change is technically difficult. It’s that nobody is confident it’s safe.
That’s why diagnosing a slow website requires looking beyond the platform.
The CMS matters. The code matters. But so do the workflows, ownership, documentation, dependencies, and guardrails surrounding them.
Because if you fix the wrong source of friction, you can spend a lot of money modernizing your website and still wonder why everything takes so long.
Put It Into Practice: Find the Friction Before You Fix It
The next time a routine website request takes longer than expected, don’t just record how long it took. Record why.
Was the delay caused by the technology itself? Did the work sit in a queue? Was ownership unclear? Did the team need an approval that added meaningful protection, or was it simply part of the existing process? Did development get involved because development was truly required, or because nobody else felt comfortable making the change?
You don’t need a sophisticated measurement system. Start by looking at five or ten recent website requests and identifying where each one slowed down.
You may discover that the CMS isn’t the biggest problem at all.
The goal isn’t to eliminate every step. It’s to make sure every step has a reason to exist.
3. The Cost of a Slow Website Isn't Just Development Time
When a website is difficult to change, the most obvious cost is time.
A developer spends longer on a request. A marketer waits for an update. A project stays open for another week.
But the bigger cost is often what doesn’t happen while everyone is waiting.
A campaign launches with a landing page the team already knows could be stronger. An outdated message stays live because changing it isn’t worth opening another ticket. A useful experiment gets pushed to next quarter. A new customer question keeps coming up, but adding the answer to the website requires more work than anyone has time to prioritize.
Eventually, website friction starts influencing which ideas the organization is willing to pursue.
Slow Changes Create Slower Learning
Imagine a paid media team sees that a campaign is generating plenty of clicks but very few conversions.
The data suggests the problem may be on the landing page. The team wants to test a clearer value proposition and reorganize the content so the most important information appears earlier.
If those changes can be created and tested relatively easily, the team can learn something.
If they require a new design request, development sprint, QA cycle, and three weeks of lead time, the calculation changes. The campaign may continue running as-is. The team may make changes to the ads instead because that’s what they can control. Or the idea may simply fall off the priority list.
The website hasn’t technically prevented experimentation.
It has made experimentation expensive enough that the team does less of it.
And that same dynamic can affect much more than testing.
Friction Changes What Teams Choose to Do
Think about some of the routine things a website needs to support.
Marketing needs a landing page for a new campaign. Sales wants a page that better answers a question prospects keep asking. SEO identifies content that should be updated. Customer feedback reveals confusing language. Analytics shows an unexpected point of drop-off. A product changes and several pages need to reflect it.
Now imagine that every one of those requests comes with a high internal cost.
Teams adapt.
They reuse a landing page that isn’t quite right. They send traffic somewhere less relevant because that page already exists. They work around the website with PDFs, forms, third-party tools, or campaign platforms. They postpone improvements until enough requests accumulate to justify a larger development project.
Those decisions may make sense individually.
Collectively, they can create an organization that is responding to the limitations of its website instead of using the website to respond to its customers.
Every Difficult Change Makes the Next Change Less Likely
This is one of the quieter consequences of website friction.
People learn which requests are painful.
If the last landing page took six weeks to launch, someone thinks twice before proposing another one. If changing a form caused tracking problems, the team becomes hesitant to touch forms. If a previous update created unexpected issues elsewhere on the site, more approvals and QA steps get added to the next request.
Sometimes those precautions are necessary.
But over time, the organization can develop a habit of avoiding change because change has historically been difficult.
That’s when website friction becomes more than an operational inconvenience. It starts affecting the organization’s ability to respond, experiment, and improve.
Put It Into Practice: Look for the Opportunities You're Leaving on the Table
One way to understand the cost of website friction is to stop looking only at the work that eventually got completed.
Look at the work that didn’t.
Think back over the last six months. Were there website improvements your team discussed but never pursued? Tests that were proposed but never launched? Campaign ideas that were simplified because the ideal experience would take too long to build? Content updates that stayed on the backlog because they required development?
Then ask why.
If the idea wasn’t valuable enough, deprioritizing it may have been exactly the right decision.
But if good ideas repeatedly die because the website makes relatively ordinary changes too difficult, that’s a different problem.
The cost of a slow website isn’t just the hours required to make a change.
It’s also the opportunities your team eventually stops asking for.
4. Flexibility Doesn't Mean Giving Everyone the Keys
There’s an obvious response to the idea that websites should be easier to change:
Do we really want everyone changing the website whenever they want?
Probably not.
A flexible website isn’t one with no rules. It’s one where the rules make sense for the work being done.
A marketer shouldn’t necessarily need a developer to update approved messaging in an existing content component. But that doesn’t mean the same marketer should be able to modify an integration, change how customer data is collected, or publish an entirely new experience without review.
The goal isn’t unlimited access.
It’s giving the right people enough control to do routine work safely, while creating appropriate guardrails around the changes that carry more risk.
Build Reusable Options Instead of One-Off Solutions
One of the most practical ways to make a website easier to change is to stop solving the same problem from scratch.
Think about landing pages.
If every new campaign starts with a blank page that needs to be designed and developed, launching campaigns will always require significant coordination.
But what if the team already has approved components for common needs?
A hero. Testimonials. FAQs. Feature comparisons. Calls to action. Forms. Statistics. Videos. Related resources.
Those components can still have rules around spacing, typography, accessibility, tracking, and brand standards. The flexibility comes from being able to combine proven pieces in different ways without rebuilding them every time.
The same principle can apply beyond page design.
Tracking can have established requirements. Common integrations can have documented patterns. Content can have defined ownership. Routine changes can follow a lighter approval path than changes involving sensitive data, functionality, or compliance.
You’re not eliminating structure.
You’re building structure that makes the common things easier.
Match the Process to the Risk
Not every website change deserves the same process.
Consider three requests:
- Correct a typo on a service page.
- Create a new campaign landing page using approved components and an existing form.
- Connect the website to a new platform that will receive customer data.
- Those changes shouldn’t require the same level of review.
Yet many organizations effectively treat them that way because they have one website process. A request goes into the same queue, moves through the same teams, and waits for the same release process regardless of what is being changed.
A better question is:
What could realistically go wrong with this change, and what controls do we need to manage that risk?
For low-risk, repeatable work, the answer may be an approved template, appropriate permissions, basic QA, and clear publishing standards.
For something more significant, development, security, legal, analytics, or additional QA may absolutely belong in the process.
The point isn’t to remove those steps.
It’s to use them when they add value.
Make the Easy Path the Right Path
There’s another benefit to creating better guardrails: teams are less likely to create workarounds.
When the official way to launch something takes too long, people find another way.
They build outside the CMS. They add another tool. They duplicate a page rather than modifying the existing template. They create a new form because nobody knows how to change the old one. They solve today’s problem quickly and leave tomorrow’s team another dependency to manage.
Sometimes a workaround is necessary.
But if the easiest way to get work done is consistently to go around your website system, that’s worth paying attention to.
A well-designed website system should make the right way of doing routine work easier than the workaround.
Sometimes the Technology Really Is the Problem
Looking beyond the technology doesn’t mean avoiding a technology investment when the evidence points there.
Sometimes the CMS really is too restrictive. The architecture has become too complicated to maintain. Critical integrations are fragile. Routine changes consistently require custom development. Technical debt has accumulated to the point that teams spend more time working around old decisions than building what the business needs next.
When those patterns appear across many different types of requests, improving individual workflows may only get you so far.
The answer could be refactoring part of the existing system, replacing an integration, rebuilding a component library, changing how parts of the website are architected, or, in some cases, moving to a different platform.
But the order matters.
Don’t start with “We need a new website.” Start with “What is making our website difficult to change?”
If the evidence eventually points to a larger technology investment, you’ll have a much clearer understanding of what that investment actually needs to solve. And you’ll be less likely to carry the same friction into a newer system.
Put It Into Practice: Start With One Repeated Request
You don’t have to redesign your entire operating model to make progress.
Look for something your team does repeatedly that creates unnecessary effort.
Maybe it’s launching campaign pages. Updating forms. Adding testimonials. Publishing new resources. Changing calls to action. Updating navigation. Creating event pages.
Then ask a practical question:
What would have to be true for our team to do this safely without reinventing the process every time?
Maybe you need a reusable component. Maybe permissions need to change. Maybe the process needs fewer approvals. Maybe tracking requirements need to be documented. Maybe your team needs a reliable staging environment. Maybe the answer really does require development work.
Solve one repeated source of friction well, and you’re not just making one website change easier.
You’re making every future version of that change easier too.
5. Measure How Hard Your Website Is to Change
If you want to know how flexible your website really is, don’t start with a list of features your CMS offers.
Start with something your team tried to change.
Choose a routine website request from the last six months. Ideally, pick something that seemed relatively simple when it was first proposed: launching a landing page, changing a form, adding a new content section, updating navigation, or modifying an existing page.
Then reconstruct what actually happened.
How long did it take from request to launch? More importantly, where did that time go?
How many people touched the request? How many times did it change hands? Did it wait in a development queue? Did someone have to figure out how an existing component worked before changing it? Were approvals required? Was there rework because requirements weren’t clear? Did QA uncover unexpected dependencies? Did anyone avoid the preferred solution because it would have taken too long?
You’re not trying to assign blame.
You’re trying to understand the system.
Separate Work Time From Wait Time
A change that takes three weeks doesn’t necessarily require three weeks of work.
Maybe the actual effort looked something like this:
Marketing spent an hour preparing the request. Design spent two hours on the update. Development spent four hours implementing it. QA spent another hour testing it.
That’s eight hours of work.
So why did three weeks pass?
The answer may be queues, handoffs, approvals, unclear ownership, release schedules, competing priorities, or the time required to find someone who knows how a particular part of the website works.
That distinction matters.
If the work itself takes too long, you may have a technology or architecture problem.
If the work spends most of its time waiting, you may have a workflow, capacity, or governance problem.
If nobody can estimate the work until someone investigates how the website is built, you may have a documentation, consistency, or technical debt problem.
The elapsed time tells you there’s friction. Where the time went helps tell you what kind.
Look for Patterns, Not One Bad Project
One painful project doesn’t necessarily mean your website is difficult to manage.
That’s why the next step is to repeat the exercise.
Look at five or ten recent website requests and compare them.
Once you’ve done this for several requests, put them side by side. A simple table can make the patterns much easier to see:
| Change | Total Time | People Involved | Biggest Delay | Unexpected Dependency |
|---|---|---|---|---|
| Campaign landing page | 3 weeks | 5 | Development queue | Form integration |
| CTA update | 4 days | 3 | Approval | None |
| New testimonial section | 2 weeks | 4 | Custom development | Template limitation |
The individual numbers aren’t the point.
The patterns are.
If development appears in nearly every routine request, ask why. If approvals create most of the waiting time, examine the approval process. If every project uncovers another unexpected dependency, the architecture may deserve attention. If nobody knows who owns certain decisions, clarify ownership before buying another piece of technology.
Ask One More Question
Once you’ve identified the friction, don’t immediately jump to a solution.
Ask:
What would make the next version of this request easier?
Not just this request. The next one.
That distinction is important.
Solving today’s landing-page problem might mean asking a developer to build the page.
Solving the recurring problem might mean creating reusable landing-page components that marketing can safely configure.
Solving today’s approval delay might mean asking someone to expedite the request.
Solving the recurring problem might mean defining which types of changes actually require that person’s approval.
Solving today’s broken integration might mean repairing it.
Solving the recurring problem might mean documenting how the integration works, who owns it, and how changes should be tested.
A workaround gets the current request across the finish line. A better system makes the next request easier.
That’s ultimately what you’re looking for.
Not a website where every change is instant.
A website where the effort required to make a change is appropriate for the change you’re trying to make.
Your Website Should Make Change Easier
Your website is going to change.
Campaigns will come and go. Products and services will evolve. Customer questions will change. Search behavior will shift. New technology will create new possibilities. Your team will learn things you don’t know today.
You can’t predict every change your website will need.
But you can decide whether making those changes will be unnecessarily difficult.
A good website isn’t just fast for the people visiting it. It should also help the organization behind it respond when something needs to change.
That doesn’t mean every request should happen immediately. Some changes deserve careful planning, development, testing, and review. The goal isn’t speed at any cost.
It’s making sure the effort matches the work.
Routine changes shouldn’t consistently become development projects. Low-risk updates shouldn’t travel through processes designed for high-risk decisions. Teams shouldn’t need institutional knowledge from one person just to understand what might break. And the easiest way to get something done shouldn’t be to create another workaround.
When those things happen repeatedly, they’re signals that the website has accumulated friction.
And that friction compounds.
It slows campaigns. It limits experimentation. It makes improvements harder to prioritize. It encourages teams to work around the website instead of improving it. Eventually, the organization starts adapting to what the website will allow rather than asking what customers and the business need from it.
The real measure of a modern website isn’t just what it can do today. It’s how easily it can change tomorrow.
Is Your Website Making Growth Harder Than It Needs to Be?
Sometimes the problem isn’t a single page, campaign, or conversion point. It’s the systems, processes, and decisions underneath them.
Anala’s Free Growth Audit looks across your website, marketing, user experience, and technology to identify friction and opportunities that may be limiting growth.
We’ll help you understand where the biggest barriers may be, what deserves attention first, and where changes could make it easier for your team to keep improving.
Because your next website change shouldn’t have to become your next website project.
