Marketing wanted to improve the customer journey. Attackers found a way to join in for their own A/B test. The Optimizely incident turned a website experimentation tool into a delivery channel for malicious JavaScript, exposing a gap between the experience companies intended to publish and the code their customers actually received.

On November 16, attackers exploited a flaw in Optimizely Web Experimentation’s signup flow to impersonate administrator users and modify customer Project JavaScript, without stealing customer passwords or compromising an Optimizely administrator account. Customer websites then delivered the modified JavaScript through their existing Optimizely integrations. The malicious scripts targeted payment information entered on webpages and cryptocurrency transactions, and Optimizely also reported an attempt to deliver a second-stage exploit targeting iOS and iPadOS devices.

Protecting that relationship, and the company’s reputation requires CISOs, CMOs, and digital engineering leaders to treat the technology powering customer experiences as a shared responsibility, not a risk that belongs to someone else.

CISO: Govern The Trust You Extend, And Prepare For It To Fail

CISOs must assess not only what data a supplier holds, but also what code it can execute, what it can change, and whose customers it can expose.

      • Assess supplier criticality by what product can change, not just what happens if it goes offline. An experimentation tool may receive a lower tier if the assessment focuses on service availability or the sensitive data the vendor stores. But the Optimizely breach showed that its integration could deliver malicious JavaScript directly into customers’ websites. A service that is optional for running the business can still be consequential for protecting customers. Require SBOMs and software supply chain transparency from suppliers whose technology executes code in sensitive or customer-facing environments and use that information to rapidly assess exposure when vulnerabilities or compromises emerge.
      • Enforce controls even for trusted suppliers . Optimizely reports that sites whose Content Security Policy (CSP) blocked the external skimmer were protected from that execution path, and that hosted payment iframes kept card fields out of its reach. The lesson is not that CSP makes third-party code safe, but that independently enforced browser controls can limit the consequences of a supplier compromise. Webpage integrity and client-side code protection tools such as Jscrambler and c/side can add another layer by detecting changes in trusted scripts and restricting unauthorized access to sensitive fields or outbound data transfers. Many web application protection platform vendors also include some client-side protections in their products. With appropriate enforcement enabled, these controls could help limit harm even when malicious code arrives through an approved supplier.
      • Plan the response before a supplier becomes an attack channel. Establish who can disable an integration, how security coordinates with engineering and marketing, which logs must be preserved, and what evidence is required before restoring service. Optimizely’s guidance called for reviewing affected pages, CSP reports, outbound browser requests, and payment activity, while retaining relevant logs. Turn those investigation requirements into a rehearsed playbook rather than an improvised checklist.

TPRM Teams: Treat the Marketing Tech Stack As Part Of The Software Supply Chain

Marketing technology rarely looks critical on paper, yet these tools can access data, change customer experiences, and execute code on public-facing websites. TPRM teams need to rethink how they identify and tier marketing third parties and:

      • Tier martech vendors based on blast radius, not spend. A third party doesn’t need a large contract or sensitive data repository to create material risk. Instead, consider whether its technology can execute code, alter customer experiences, access credentials, transmit data, or connect to other critical platforms. Factor privileged access, embedded code, customer-facing functionality, and downstream dependencies into tiering. A small martech provider can create an outsized exposure when its technology runs directly in a customer environment.
      • Stop treating the initial assessment as a durable picture of risk. The provider you assessed 18 months ago may not be the provider you rely on today. Acquisitions, new AI features, additional integrations, changing sub-processors, and expanded data use should trigger reassessment. Build those triggers into the relationship rather than relying on the next review cycle.
      • Build containment and exit rights into the relationship. Require suppliers to support emergency suspension, credential revocation, removal of embedded code and tags, evidence preservation, and secure restoration within defined timeframes. Contracts should also specify breach-notification requirements, access to relevant logs and forensic findings, and obligations extending to subprocessors.

CMO: Conversion Gains Mean Little If Customers Lose Trust

Marketing technology increasingly sits directly in the customer experience. CMOs therefore need to understand not just what their martech improves, but what customer experiences depend on it and what happens when that technology becomes a source of risk and:

      • Know where martech touches the customer journey. Map experimentation tools, analytics tags, pixels, personalization services, and other marketing technologies to the experiences where they operate. Pay particular attention to checkout, payments, authentication, and other sensitive interactions. Optimizely’s compromised JavaScript was capable of skimming payment-card information, replacing cryptocurrency wallet addresses, and collecting other browser data.
      • Design campaigns and experiences to degrade safely with disabled martech. Modern customer experiences cannot operate without martech. Experimentation, personalization, measurement, and other capabilities increasingly shape how the experience functions. But they don’t all have to function all the time. Work with digital and security teams to identify which martech capabilities can be temporarily disabled while a third-party provider investigates and remediates an incident. Where the platform permits it, control experience delivery, data collection, custom code execution, and outbound transmission separately rather than treating the entire integration as a single on-or-off capability. Design those fallback states in advance so customers can still complete essential tasks, even when the experience is temporarily less personalized, optimized, or measurable.

Digital Engineering Leader: Govern The Code Your Customers Actually Receive

Your release pipeline is not the only route to production. In the Optimizely breach, the vendor’s CDN served the altered content rather than being independently compromised. Digital engineering leaders must account for third-party code that can change after their own application has been reviewed, tested, and released and:

      • Extend change governance beyond your own deployments. Inventory third-party scripts and identify who can modify their behavior, how changes reach production, and what review or approval controls are available. Treat experimentation platforms, tag managers, and other remotely updated integrations as governed production change channels, with controls proportionate to what a change can execute, access, or transmit. But don’t force every marketing change through the full software release process. Preserve marketer self-service for lower-risk changes such as copy, imagery, layout, and predefined experience variants, while requiring additional review for custom JavaScript, new external domains, identity or authentication flows, and changes involving payment or other sensitive data. Monitor the code and behavior delivered to visitors rather than assuming an approved integration remains unchanged.
      • Limit when optional scripts run in sensitive interactions. Don’t abandon experimentation on checkout, payment, authentication, and other high-value interactions. Instead, minimize the duration and authority of the code used to optimize them. Optimizely recommended removing its snippet from sensitive-input pages where customers were not running experiments. Load experimentation scripts on sensitive pages only when an approved experiment or another explicitly approved capability requires them. When continued experimentation requires a persistent base snippet, disable completed experiments and remove unnecessary custom JavaScript rather than repeatedly uninstalling and reinstalling the platform integration. Where possible, isolate sensitive fields behind independently controlled boundaries, such as hosted payment iframes, so experimentation can change the surrounding experience without gaining access to payment credentials or other sensitive inputs. The objective is to preserve optimization while reducing the window and scope of exposure.
      • Make third-party changes observable and reversible. Establish a tested way to disable an integration while preserving the customer’s essential task and falling back to a known default experience, and define the checks required before restoring it. Capture browser-security telemetry that helps distinguish expected behavior from unexpected outbound connections. Optimizely’s investigation guidance called for reviewing CSP violation reports and browser requests to malicious domains. Use that guidance to build detection and recovery procedures before the next supplier incident.

Optimizely is far from the only martech vendor whose product introduces vendor-controlled JavaScript into customer-facing websites. And this risk isn’t limited to website scripts. The recent compromise of third-party providers holding marketing and customer-engagement data for JPMorgan Chase, Visa, and Mastercard shows how martech suppliers can become a shared point of exposure across multiple organizations. Organizations need to treat marketing technology as part of the software supply chain, not as infrastructure that sits outside it. Security, marketing, and engineering leaders need to understand where that trust exists, put boundaries around it, and prepare for the moment it fails. For more on building those practices across the software lifecycle, read our Software Supply Chain Security Best Practices For Producers, Operators, And Choosers report.

Share