Fragile to Flexible: Easy-to-Edit Emails with No Custom Modules
This information is part of my presentation at Salesforce Connections 2026.
Today I want to tell you the story of a Salesforce Marketing Cloud template that led me to rethink how I build editable email systems in Content Builder. So let’s go back to the beginning… to when the request first came in.

At the time, NPR was looking to redesign their Indicator newsletter. They wanted something that felt more editorial… more modular… more Morning Brew-y. The mockup they gave me had individual cards with rounded corners, unique background colors, a hero image, and a byline.
Everything was stacked together into a very modern editorial layout.

So, I knew custom code was going to have to come into play here. I coded for the goal of maximum editability. My first instinct was to go for a free-form content block and just plop the necessary code into the HTML Editor. That was going to be the easiest way for me to give NPR what they wanted – rounded cards with background colors all with editable content. So I did just that… One GIANT free-form content block with everything inside of it: the background color, the rounded corners, the headline, the paragraph, the image, the button. Basically, the entire card.
I showed these newly coded content blocks to NPR and they immediately identified a problem. The free-form editing experience was not the same as the system modules the team was used to. A lot of hands touch this newsletter, so it needed to be as easy as possible for everyone, including people across teams, to be able to edit. And my mega module just wasn’t gonna cut it. I had solved for design fidelity, and forgot about usability.
The free-form removed the thing SFMC users actually rely on: ease of editing, including the ability to edit one module at a time. Because everything lived inside that freeform block, that meant: no block settings, no simple drag-and-drop editing, no easy content swapping. And if somebody needed to edit something complicated, they were going to have a come-to-jesus moment with the HTML editor.
Allowing every part of the card to be edited during a content swap left the door wide open for accidental changes. A carriage return in the content builder editor is not the same as HTML spacing. It basically turned the editing experience into a hostage negotiation.
At the time, I thought flexibility meant giving users complete control over the module itself. But NPR didn’t just need design flexibility. They needed workflow flexibility too.” This all-in-one didn’t recreate the usability of the standard SFMC system module editing experience, something NPR relied on heavily. My contacts at NPR told me they needed the solution to use the system content blocks and that was non-negotiable.

The problem I noodled on was how to make the content blocks stop being responsible for the card styling. Block settings could give me a background color, yes, but not the rounded corners.
See, I had already learned that trying to add css styles in the head of the email using only the classes that Salesforce has in their templates by default is a living nightmare.
For those of you who don’t use CSS, the main problem is that CSS has no way to target the parent of a content block. It’s cascading style sheets, not climbing style sheets. Under normal circumstances, I’d solve that by adding a class to the wrapper. But salesforce email templates seem to believe in austerity measures for classes.
So, if I could not add classes to the HTML, I’d have to use attribute selectors, which have email support of somewhere between questionable and… SCOFF.
I quickly came to the conclusion that the card styles had to move OUTSIDE the editable content. So instead of building giant custom card modules, I started with a standard SFMC template and basically deleted everything except the content areas. Then I wrapped those content areas in tables that handled the card styles. This way, the marketers could still use normal system text, image, and button blocks, but the visual card structure stayed protected on the template level.
However, this was not all roses. When I put the styles on the table around the content blocks, that locked the cards into a specific, unchangeable order. But in exchange for a system that was dramatically more stable and usable, the cards had to stay in the same order for every email. That’s a pretty good trade.

So, this is what that ended up looking like in practice. Each card became its own dedicated content area inside the template. The editable region was the content area itself, while the surrounding, uneditable table handled the styling. I could finally separate the content from the styles. Was it an elegant solution? Absolutely not. Did it work and give NPR exactly what they wanted with only a small downside? Yeah it did.

The marketers could use a normal text block, a normal image block, and a normal button block. It had all the flexibility of standard system modules while the template quietly protected the visual structure around them. There’s no custom code inside the content blocks. No giant freeform editing experience. Just normal Content Builder workflows inside a controlled layout system.

So, I delivered and NPR started testing it. At this point we had dark cards with light text and light cards with dark text. This would become an issue. Almost immediately, NPR pointed out that links that should have been beige were showing up as dark green. See, I had used the Design tab settings on the template level to set the link color out of habit. And it worked great… right up until those global styles started overriding my inline link colors. So in the dark cards, the links technically still existed, but visually they basically just disappeared. Which is not ideal for something people are supposed to click.
I temporarily channeled Thanos. Fine… I’ll do it myself.

So instead of relying on the global template link styles, I started assigning card-specific classes directly to the wrapper tables. Each card got its own class based on the background color. I set the link color to each specific card class. The beige card got a dark green link, the blue card got a beige link, and so on and so forth. The only extra wrinkle was making sure the text link styles didn’t accidentally override the text color of the buttons.

Luckily, there was an easy fix to the button problem. I gave the beige background buttons with dark green text their own dedicated classes. In this case beigebutton (very original, I know) and explicitly excluded them from the paragraph link styling. That way the text links could inherit the text color theme while the buttons kept their own styling completely separate.
Finally, all the competing requirements stopped fighting each other. The cards stayed consistent. The NPR team stayed inside familiar workflows.
And the whole system became dramatically harder to accidentally break.
Behold! My creation.

At this point, the actual client problem was solved.

And this is where my developer brain started getting a little too excited. But once the content and presentation layers were separated, it became very obvious that the architecture could do a lot more than NPR actually needed, or frankly, wanted.

Now, to be very clear, NPR did not ask for this. But I can’t leave well enough alone. Technically, if the card styling is already separated from the content, there’s no reason the themes HAVE to stay manually assigned. You could set each theme to the correct background color and complementary text color dynamically through AmpScript and let the HTML simply output whatever colors were passed in via the variables.
Yeah, I wasn’t solving a business problem anymore. I was just seeing how far I could push the architecture.

You know that phrase, absolute power corrupts absolutely? I took the original card order: beige, dark green, light green, and just mixed it all up for funsies. First purple, followed by blue, beige, light green. It was all the same structure, the same content areas, and the same exact reusable HTML, just with newly assigned background and text colors thanks to AmpScript.
Then I finally rested.

What this project really changed for me was how I think about flexibility. Because for a long time, I thought flexibility meant more freedom, customization and control. But that’s not actually what most teams need. Most teams don’t want to rebuild layouts from scratch every week. They want guardrails. They want consistency. They want systems that are hard to accidentally break. That completely changed how I think about editable email architecture. Because flexibility isn’t just giving marketers more control. It’s giving them safe control. This system gave NPR modern editorial layouts, reusable system modules, normal Content Builder workflows, and all without forcing marketers into custom code or fragile editing experiences.
And getting this many moving pieces to work together consistently inside enterprise email…
sometimes feels a little bit like successfully herding cats. But if the architecture is solid enough, you can actually do it.
Begin Your Journey to Better Emails
