Before diving into key concepts, ensure that Optimizely CMS is set up on your local machine. You can refer to the detailed setup guide here: “Optimizely CMS Set Up: A Developer’s Guide / Blogs / Perficient”

Once Optimizely CMS is successfully configured, the following core concepts will help you understand how to work with pages, blocks, and rendering in your project.

Understanding Page Types and Block Types

Page Types

• Represent full pages in the CMS (e.g., Home Page, Article Page).
• Defined as C# classes inheriting from PageData.
• Each public property becomes a field editors can fill in the CMS.

Block Types

• Represent reusable content components (e.g., Teasers, Banners).
• Defined as C# classes inheriting from BlockData.
• Can be embedded in pages or reused across multiple pages.

In the Optimizely CMS project (created via dotnet new epi-alloy-mvc) add the files as below.

Example: Basic Page Type

MainBody: Rich text field using XhtmlString for formatted content.

MainContentArea: For adding block into pages.

After compiling, the CMS UI will reflect this new page type, and editors can start creating pages.

Creating a Page

• Navigate to the page tree.
• Right-click a parent page → New Page.
• Select your new page type (e.g., “Standard Page”).
• Fill in the fields like Main Body and Main Content Area.

Working with Blocks

Blocks are reusable content chunks. Here’s how to create a simple text block:

You can now drag and drop this block into any compatible page area.

Creating a Block

• Open the Assets Panel.
• Click New Block → Choose “Teaser Block”.
• Fill in the Heading and Image.
• Drag and drop the block into a content area on a page.

Routing and Rendering Views

Create Razor View for StandardPage

1. A class /Models/Pages/StandardPage.cs
2. Create a controller in /Controllers/StandardPageController.cs
   
3. Create the Razor view. Create the file: /Views/StandardPage/Index.cshtml

For adding block into pages add a content area to the razor view.

1. 1. In /Models/Pages/StandardPage.cs, add a property
      
      This creates a drop zone in the CMS UI where editors can add blocks.
   2.  In /Views/StandardPage/Index.cshtml, update the view
      
      This renders whatever blocks the editor drops into MainContentArea.

Once compiled and the site is running:

• Open a page of type Standard Page
• Find a field called Main Content Area
• From the Assets Panel, drag blocks (like Teaser Block) into this area
• Publish the page and view it in browser.

Admin & Edit mode

Access the CMS back office:

• Navigate to /episerver
• Login with the seeded admin account or set one up using Identity or ASP.NET Core Identity providers

Preview & Debugging

Use Visual Studio’s debugger, breakpoints, and logs. CMS also offers content preview modes and version management tools.

Deployment Basics

You can deploy Optimizely CMS using:

• Azure App Services
• IIS on Windows Server
• Docker (with a configured image)

Use dotnet publish for build output:

Content Editing Experience

Optimizely offers:

• Inline editing
• Drag-and-drop interface
• Preview modes by device and visitor group

Content editors can switch languages, schedule publishing, and experiment with layout—all from the CMS UI.

Conclusion

Optimizely CMS offers a structured and extensible framework for building content‑driven websites. By understanding core concepts such as Page Types, Block Types, and view rendering, developers can quickly create scalable and reusable components. Combined with its intuitive editing tools, Optimizely enables teams to deliver and manage content efficiently, making it a strong foundation for modern digital experiences.

When using Optimizely Commerce Spire with React 18 or later, developers frequently encounter hydration issues—pages render blank or React shows hydration warnings. This typically occurs when the HTML rendered on the server does not match what React expects on the client.

This blog covers:

• Why hydration issues occur after upgrades
• The difference between CMS content and custom properties
• How to use parse, parserOptions, and transformContentHtml correctly
• Best practices for Spire projects

Why Hydration Issues Occur

React 18 introduced stricter hydration checks. Hydration is the process by which React attaches event listeners and state to server-rendered HTML. If the HTML structure differs between the server and the client, React logs warnings or hydration can fail completely.

In Optimizely:

• Existing content (created before the upgrade) may contain HTML structures such as <html>, <body>, and <title> tags.

• After the upgrade, when you re-save the text in Optimizely Admin, these extra tags (<html>, <body>, <head>) are automatically removed.

Note: If you do not re-save manually, the old content will still retain these tags, resulting in inconsistent HTML between the server and the client.

This mismatch causes blank pages or hydration warnings since React expects a consistent DOM structure.

CMS Content vs Custom Properties

Spire accepts HTML content from two main sources:

• CMS content: Standard pages and widgets from the CMS. These typically contain clean HTML fragments suitable for direct parsing.
• Custom properties: Data from the admin panel for Product, Category, Warehouse, Brand, and Location. These often include legacy HTML or encoded tags, which can cause mismatches during hydration.

Rule of thumb:

• CMS content → parse directly
• Custom properties → normalize first with transformContentHtml, then parse

Correct Rendering Approach

For CMS content

{parse(category.htmlContent, parserOptions)}

For custom properties

{parse(transformContentHtml(category.htmlContent), parserOptions)}

This ensures that CMS content is rendered as is, while custom property content is cleaned up before rendering.

Utility Functions Overview:

• transformContentHtml
  • Import:

    import transformContentHtml from "@insite/client-framework/Common

  • Purpose:
    • Detects full HTML documents and extracts <body> content.
    • Encodes special characters where required.
    • Normalizes legacy HTML so that it is safe and compatible with React hydration.

• parse
  • Library: html-react-parser
  • Purpose:
    • The parse function converts HTML strings into React elements.
    • React cannot render raw HTML strings directly, so parsing into elements is the correct approach to display dynamic HTML content.

• parserOptions

  • Import:

    import { parserOptions } from "@insite/client-framework/Common

  • Purpose:
    • Defines how HTML tags and attributes are transformed or sanitized during parsing.
    • Removes unsafe attributes.
    • Allows customization of tag and attribute replacements.

Best Practices

• If you only have 10–15 pages, re-save them in Optimizely Admin to remove outdated tags.
• Always choose the appropriate parsing strategy depending on the content source (CMS vs custom properties).
• Validate the content of custom properties before rendering to prevent inconsistent HTML and hydration issues.

Conclusion

• Mismatched HTML structures cause hydration problems in React 18 when using Optimizely Spire.
• For CMS content, use parse with parserOptions.
• For custom properties, normalize with transformContentHtml before calling parse.
• This approach avoids blank pages after upgrades and ensures reliable, accurate rendering in Spire projects.

]]> https://blogs.perficient.com/2026/01/05/rendering-html-content-in-optimizely-spire-correct-handling-for-cms-and-custom-properties/feed/ 0 389344 https://blogs.perficient.com/2026/01/05/creating-rounded-corner-buttons-for-email-templates-without-distortion/ https://blogs.perficient.com/2026/01/05/creating-rounded-corner-buttons-for-email-templates-without-distortion/#respond Tue, 06 Jan 2026 04:44:10 +0000 https://blogs.perficient.com/?p=389339

Creating email templates that render consistently across major email clients (Outlook, Gmail, Yahoo, Apple Mail) is challenging for developers due to differences in rendering engines. Common issues include distorted corners, misaligned text, and inconsistent heights—especially in Outlook, which uses Microsoft Word’s engine.

In this article, I’ll show you how to create rounded-corner buttons that work in all major email clients. We’ll look into it:

• Creating Primary and Secondary buttons with HTML and VML
• The importance of conditional comments
• Using pt units instead of px for accurate Outlook rendering
• These approaches are applicable to both Outlook and non-Outlook clients.

Primary Button: Solid CTA

Main call-to-action (e.g., “Sign Up Now”) with solid background, no border, and pt-based radius for Outlook.

<div class="buttonWrapper">
 <!--[if mso]>
              <v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" rel="noopener" target="_blank" 
href="url"
 style="height:28.5pt;v-text-anchor:middle;width:132pt;" arcsize="22.5pt" stroke="f" fillcolor="#C91E24">
                <w:anchorlock/>
                  <center>
            <![endif]-->
            <a rel="noopener" target="_blank" 
href="url "
 style="mso-font-alt:9pt;background-color:#C91E24;border-radius:30px;color:#ffffff;display:inline-block;font-size: 9pt; line-height:28.5pt;font-weight:700;text-align:center;text-decoration:none;width:132pt;-webkit-text-size-adjust:none;">
              <span style="font-size:9pt;mso-font-alt:9pt;">Create your password</span>
              </a>
            <!--[if mso]>
                </center>
              </v:roundrect>
            <![endif]-->
</div>

This is how the button will appear following the above changes:

Key VML attributes (Primary):

• arcsize=”22.5pt”: Specifies corner radius
• stroke=”f”: Removes border for a clean appearance
• fillcolor=”#C91E24″: Specifies the solid background color

Secondary Button – Outlined Style

Non-critical CTA (e.g., “Learn more”) with border and white background.

<div class="buttonWrapper">
<!--[if mso]>
  <v:roundrect xmlns:v="urn:schemas-microsoft-com:vml"
xmlns:w="urn:schemas-microsoft-com:office:word"
href="url"
style="height:25.5pt;v-text-anchor:middle;width:132pt;" arcsize=" 22.5pt"
strokecolor="#C91E24" fillcolor="#ffffff">
<w:anchorlock/>
<center style="color:#C91E24;font-family:sans-serif;font-size:9pt;font-weight:bold;width:132pt; mso-line-height-rule:exactly;height:9pt;">
  Create your password
</center>
  </v:roundrect>
<![endif]-->
<!--[if !mso]><!-- -->
  <a 
href="url"
style="display:inline-block;background-color:#ffffff;border:1.5pt solid #C91E24;border-radius:22.5pt;color:#C91E24;font-family:sans-serif;font-size:9pt;font-weight:bold;text-align:center;text-decoration:none;width:132pt;-webkit-text-size-adjust:none;mso-hide:all;">
  <span style="
   padding: 6pt 1pt;font-size:9pt;line-height: 15pt;display: block;
">Create your password</span>
  </a>
<!--<![endif]-->
</div>

This is how the button will appear following the above changes: 

Key VML attributes (Secondary):

• arcsize=”22.5pt”: Specifies corner radius
• strokecolor=”#C91E24″: Specifies the border color
• fillcolor=”#ffffff”: specifies the white background color

What Happens to Non‑MSO Clients (Gmail, Yahoo, Apple Mail)?

Make anchors act like buttons by setting display: inline-block; use background-color, border-radius (and border for outlines), and tweak font-size/line-height/padding for alignment; add -webkit-text-size-adjust: none to prevent mobile scaling.

Understanding Conditional Comments

• <!–[if mso]> … <![endif]–>
  Content is only displayed in Microsoft Outlook (desktop versions). This block contains VML code that renders rounded-corner buttons.
• <!–[if !mso]><!– –> … <!–<![endif]–>
  Displays content in all non-Outlook clients, including Gmail, Yahoo, Apple Mail, and mobile apps. This section comprises normal HTML and CSS.

How It Works

• Outlook uses VML because it does not support CSS features such as border-radius.
• Some clients utilize the HTML tag with CSS style for rounded corners.
• <w:anchorlock/> keeps text centered within the VML structure.
• mso-hide:all; hides the HTML version in Outlook to prevent duplication.

Why pt Units (Not px)?

Outlook’s Word engine handles pt reliably for height, width, line-height, radius, and padding.

Best Practices 

• VML for Outlook + HTML/CSS for others via conditionals
• Inline styles everywhere
• Primary: arcsize=”22.5pt” stroke=”f” fillcolor=”#C91E24″
• Secondary: arcsize=”22.5pt” strokecolor=”#C91E24″ fillcolor=”#ffffff”
• Match dimensions across blocks; adjust as needed

Conclusion

Use conditionals for Outlook VML + HTML elsewhere, pt units, and matching dimensions for consistent rounded buttons across clients.

Justin Racine, Principal of Commerce Strategy, has covered some of the most memorable commerce, retail topics and customer experiences to hit our newsfeeds in recent years. He has written for CMSWire on a wide range of subjects and has previously been awarded Contributor of the Year, so it’s no surprise that he has once again earned the honor for 2025.

This year, Justin decoded the Manning brothers’ secret playbook for brand loyalty and urged the world to recognize how customers are using AI in their holiday shopping. He wrote about everything from Taylor Swift to KFC, but we wanted to know which articles readers shared, liked, and returned to the most. Below are the top five CMSWire pieces Justin published in 2025.

Number 5 – Alexa, Meet ChatGPT: New Ecommerce Customer Experience Party Has Better Snacks

Justin explores how the integration of conversational AI like ChatGPT with voice assistants such as Alexa will reshape commerce by creating more natural, personalized shopping experiences. With generative AI and voice-driven interfaces working together, brands can deliver seamless product discovery, recommendations, and transactions that feel like real conversations.

Number 4 – The Future for Your Consumers Isn’t Social Media, It’s Social Life

From the early days of dial-up to the rise of social media, being online has always been about discovering what’s happening and who’s involved. Justin explains how social media is evolving into what he calls “social life,” where AI-powered wearables and connected devices blend digital and physical interactions. Instead of likes and passive engagement, future platforms will emphasize real-time, interactive experiences that reshape how we shop, date, and socialize.

Number 3 – The Future of Customer Experience Is Built for AI, Not Humans

Justin spent much of the year writing about the future of customer experience, and his prediction is bold: humans are no longer the primary focus. He argues that autonomous AI agents will increasingly make decisions and purchases on behalf of consumers. To prepare, brands must overhaul product data, adopt composable commerce architectures, and support dynamic, AI-generated product pages that respond to real-time queries.

Number 2 – The Absolute Top Moments From NRF 2025: Retail’s Big Show

The National Retail Federation’s annual conference kicks off the year, and Justin’s recap is always a reader favorite. His 2025 takeaways highlighted how AI’s practical impact is now front and center in most retailers’ plans. He also emphasized the importance of the show floor embodying the essence of retail and noted several provocative discussions about the future of digital commerce.

Number 1 – What Red Lobster’s New CEO Teaches Us About Customer Experience Strategy

The most-read article of the year was Justin’s deep dive into the revival of a well-known seafood chain. He unpacked how Damola Adamolekun, Red Lobster’s new CEO, turned around a struggling franchise with small but meaningful changes. Updates to menus, ambiance, and overall experience led to significant improvements in customer satisfaction. Justin also highlighted how authenticity and transparency strengthened trust among both employees and guests, improving overall brand perception.

That’s a Wrap on Justin’s Top CMSWire Articles for 2025

If you can’t get enough of Justin’s insights, keep an eye out for his upcoming article covering NRF: Retail’s Big Show in early January. We’ll be sharing live coverage from the first few days of the conference, and if you plan to attend, be sure to meet Justin and the rest of our experts.

#1. Introduction

If you’re knee-deep in building apps, you already know APIs are the backbone of everything. Testing them? That’s where the real magic happens. For years, we’ve relied on tools like Postman and Insomnia to send requests, debug issues, and keep things running smoothly. But lately, there’s a buzz about something new: Bruno. It’s popping up everywhere, and developers are starting to make the switch. Why? Let’s dive in.

What Exactly is Bruno?

Picture this: an API client that’s open-source, super speedy, and puts your privacy first. Bruno isn’t some bloated app that shoves your stuff into the cloud. “No” it keeps everything right on your local machine. Your API collections, requests, all of it? Safe and sound where you control it, no cloud drama required.

Bruno is built for developers who want:

• Simplicity without compromise
• High performance without unnecessary extras
• Complete freedom with open-source flexibility

It’s like the minimalist toolbox you’ve been waiting for.

Why’s Bruno Suddenly Everywhere?

Bruno solves the pain points that frustrate us with other API tools:

• Privacy First: No forced cloud uploads your collections stay local. No hidden syncing your data stays completely under your control.
• Fast and Lightweight: Loads quickly and handles requests without lag. Perfect for quick tests on the go.
• Open-Source Freedom: No fees, no lock-in. Collections are Git-friendly and saved as plain text for easy version control.
• No Extra Bloat: Focused on what matters API testing without unnecessary features.

Bottom line: Bruno fits the way we work today collaboratively, secure, and efficient. It’s not trying to do everything; it’s just good at API testing.

#2. Key Features

Bruno keeps it real with features that matter. Here’s the highlights:

1. Totally Open-Source

• No sneaky costs or paywalls.
• Peek under the hood anytime—the code’s all there.
• A bunch of devs are pitching in on GitHub, making it better every day. Wanna join? Hit up their repo and contribute.

2. Privacy from the Ground Up

• Everything lives locally.
• No accounts, no cloud pushes—your requests don’t leave your laptop.
• Ideal if you’re handling sensitive APIs and don’t want Big Tool Company snooping.
• Bonus: Those plain text files play nicely with Git, so team handoffs are seamless.

3. Light as a Feather, Fast as Lightning

• Clean UI, no extra bells and whistles slowing you down.
• Starts up in a flash and zips through responses.
• Great for solo endpoint tweaks or juggling big workflows without your machine groaning.

Getting Bruno Up and Running

Installing Bruno is simple. It works on Windows, macOS, and Linux just choose your platform and you’re good to go.

#3. Quick Install Guide

Windows:

1. Head to Bruno’s GitHub Releases page.
2. Grab the latest .exe file.
3. Run it and follow the prompts.
4. Boom—find it in your Start Menu.

macOS:

1. Download the .dmg from Releases.
2. Drag it to Applications.
3. Fire it up and get testing.

Linux:

1. Snag the .AppImage or .deb from Releases.
2. For AppImage: chmod +x Bruno.AppImage then ./Bruno.AppImage.
3. For .deb: sudo dpkg -i bruno.deb and sudo apt-get install -f.

GUI or CLI? Your Call

• GUI: Feels like Postman but cleaner. Visual, easy for building requests on the fly.
• CLI: For the terminal lovers. Automate tests, hook into CI/CD, or run collections like

          bruno run collection.bru –env dev.

#4. Build Your First Collection in Minutes

Bruno makes organizing APIs feel effortless. Here’s a no-sweat walkthrough.

Step 1: Fire It Up

Launch Bruno. You’ll see a simple welcome screen begging for a new collection.

Step 2: New Collection Time

1. Hit “New Collection.”
2. Name it (say, “My API Playground”).
3. Pick a folder—it’s all plain text, so Git loves it.

Step 3: Add a Request

1. Inside the collection, click “New Request.”
2. Pick your method (GET, POST, etc.).
3. Drop in the URL, like https://jsonplaceholder.typicode.com/posts.

Step 4: Headers and Body Magic

• Toss in headers: Content-Type: application/json.
• For POSTs, add a body like:

JSON

{
"title": "Bruno Blog",
"body": "Testing Bruno API Client",
"userId": 1
}

Step 5: Hit Send

Click it and watch the response pop: status, timing, pretty JSON—all right there.

Step 6: Save and Sort

Save the request, make folders for envs or APIs, and use vars for switching setups.

#5. Bruno vs. Postman: Head-to-Head

Postman’s the OG, but Bruno’s the scrappy challenger winning hearts. Let’s compare.

1. Speed

• Bruno: Lean and mean—quick loads, low resource hog.
• Postman: Packed with features, but it can feel sluggish on big projects. Edge: Bruno

2. Privacy

• Bruno: Local only, no cloud creep.
• Postman: Syncs to their servers—handy for teams, sketchy for secrets. Edge: Bruno

3. Price Tag

• Bruno: Free forever, open-source vibes.
• Postman: Free basics, but teams and extras? Pay up. Edge: Bruno

Feature	Bruno	Postman
Open Source	Yes	No
Cloud Sync	No	Yes
Performance	Lightweight	Heavy
Privacy	Local Storage	Cloud-Based
Cost	Free	Paid Plans

#6. Level Up with Advanced Tricks

Environmental Variables

Swap envs easy-peasy:

• Make files for dev/staging/prod.
• Use {{baseUrl}} in requests.
• Example:

{
"baseUrl": "https://api.dev.example.com",
"token": "your-dev-token"
}

Scripting Smarts

Add pre/post scripts for:

• Dynamic auth: request.headers[“Authorization”] = “Bearer ” + env.token;
• Response checks or automations.

#7. Community & Contribution

It’s community-driven:

• Repo: https://github.com/usebruno/bruno
• Contribute: Fork, branch, PR. Report bugs, chat ideas—help build the future.

#8. Conclusion

Bruno isn’t just another API testing tool it’s designed for developers who want simplicity and control. With local-first privacy, fast performance, open-source flexibility, and built-in Git support, Bruno delivers everything you need without unnecessary complexity.
If you’re tired of heavy, cloud-based clients, it’s time to switch. Download Bruno today and experience the difference: Download here.

The adoption of microservice‑based architectures has grown exponentially over the past decade, often driven more by industry trends than by a careful evaluation of system requirements. This phenomenon has generated unnecessarily complex implementations—like using a bazooka to kill an ant. Distributed architectures without solid foundations in domain capabilities, workloads, operational independence, or real scalability needs have become a common pattern in the software industry. In many cases, organizations migrate without having a mature discipline in observability, traceability, automation, domain‑driven design, or an operational model capable of supporting highly distributed systems; as a consequence, they end up with distributed monoliths that require coordinated deployments and suffer cascading failures, losing the benefits originally promised by microservices (Iyer, 2025; Fröller, 2025).

Agentforce World Tour Boston is where leaders are turning AI ideas into everyday wins. Perficient will be onsite connecting with customers and partners, and we invite you to keep the conversation going at our AI Innovation Reception, a networking happy hour co‑hosted with Salesforce.

Brainstorming sessions have a love-hate situation. Half the team is excited, the other half dreads it. The truth is, anyone can be creative, but it doesn’t happen by accident – it takes intentionality.

The key is preparation. If people show up cold, they’ll default to routine thinking or recycle old ideas. To break free, our brains need to loosen up first.

After years of leading innovative teams, I’ve learned what works. Here’s a simple game plan to help your team show up ready to think differently and generate fresh ideas together.

Your Job as the Facilitator

Your goal is to make sure the team is ready for what might feel like an unusual process. This isn’t a standard meeting. If your team walks into the same room, sits in the same chairs, sipping the same coffee, they’ll fall into routine and recycle old ideas.

Jumping in cold with, “Now, let’s be creative!” usually leads to either awkward silence or one person dominating the conversation. Neither sparks innovative ideas from the team at large.

Instead, help the team stretch beyond their daily rut. Give them a clear game plan so they arrive ready to think differently and generate ideas that excite everyone.

Week Before: Early Prep

Start the conversation early so people have time to adjust and prepare. Share the problem or opportunity you’ll tackle and why it matters. Encourage participants to jot down initial ideas ahead of time to prime their creative pump and avoid awkward silences for you. If you want, you can ask them to send a few ideas to you ahead of time.

Lay out expectations clearly:

1. Send the agenda so everyone knows what to expect.
2. Focus on idea generation, not debate. Quantity over quality with an “idea factory.”
3. Encourage wild thinking. Suspend reality for a moment, because one impossible idea can spark a feasible one.
4. Set aside ownership. Collaboration is key. Great ideas are evolved, changed, merged.
5. Share inspiration. Send the team an article, video, or data to start the train of thought.
6. Suggest habit shifts. Exercise, meditation, or quiet time can help reset the mind ahead of the session.

Consider a message like:

“Next week we’re going to think differently together. I’m not expecting perfect solutions, but instead want you to arrive with your mind loosened up and ready to play. Here’s how to prepare…”

Day Before: Prime the Mindset

Send a reminder the day before to reinforce excitement and set expectations. If you’ve received early ideas, acknowledge them with enthusiasm and let the team know this is meant to be fun.

Offer quick prep tips:

1. Revisit the “why” of this session. Remind them of the importance of participation.
2. Ask them to avoid distractions in the morning. No early morning emails!
3. Set the tone of the event as judgment-free, experimental, and collaborative. Similar to comedy improv: use “Yes, and…,” “What if…,” or “Could we…?”
4. Emphasize the evolution of ideas and how they grow and change. Building together is the goal.
5. Note that ideas start out rough, but you can polish them. Even the opposite of a good idea can spark another great idea.
6. Suggest breaking their personal routine. Try small disruptions: take a new route to work, wear something unusual, listen to a different music genre. Maybe walk up the stairs backwards.

Consider a message like:

“To prepare your mind for tomorrow, I’m challenging you to break from your norm tonight and tomorrow morning. Try at least two of these suggestions or invent one of your own. Let’s see who finds the weirdest personal disruption!”

Day Of: Set the Stage

First impressions matter. Start the session a little later than usual (we asked them to not hop into work before the session), we want them to arrive fresh. Have the space ready before they walk in.

Make the room feel different:

• Atmosphere: Light background music. A slideshow or posters with creative quotes. Snacks and beverages.
• Seating: Avoid typical conference room setups. Use casual seating or standing tables for comfort and encourage movement throughout the session.
• Tools: Whiteboards, large pads of paper, notebooks, sticky notes, pencils, pens, markers, colored dot stickers for voting, and a screen or projector for references.

The goal here is to signal that this isn’t a typical meeting – it’s a space for creativity.

During the Session

Keep things casual while welcoming everyone as they arrive. Explain why the meeting space looks different and ask if anyone disrupted their morning routine. Be prepared to share your own example if no one chimes in. Keep it light and fun! Aim for laughs, no pressure. Icebreakers work OK, but I prefer a few optical illusions and brain teasers for warming people up.

You should have helpers ready to capture ideas, snap photos of boards, and tally votes. If you use breakout groups, assign a helper to each group.

As facilitator, reiterate the rules:

1. Restate the objective for today. Fresh ideas are needed.
2. No bad ideas. Reviews and debates come later.
3. No competition. Fighting over ownership limits creativity. (Your helpers should keep note of who’s passionate about ideas for follow-up.)
4. Wild ideas are welcome! Spin-off ideas are expected.
5. Quantity over quality. More ideas provide more chances for breakthroughs.
6. Free to move around. Standing, pacing, and changing seats keeps energy up.

Be ready to help if people get stuck:

• Use lateral thinking such as random words, images, or “How would Einstein/Steve Jobs/SpongeBob solve this?”
• Flip the problem by trying the opposite approach or by exaggerating to an illogical extreme.
• Adding constraints can help creativity.
• Use speed rounds. Tight limits often spark creativity. “How many unique ideas can you generate in 5 minutes?”
• You should prepare at least one “crazy idea bomb” to break out of slumps if they happen.

Session End

Wrap up on a positive note. Thank everyone for their time and willingness to break out of their routines. Reference a funny idea or moment from the session, if one stood out, trying to end with laughs.

Invite quick reflections:

• What excited or surprised you most today?
• What helped loosen you up?
• What would you want to do again next time?

End with an outline of next steps so the team knows this isn’t the end of the process. Share how ideas will be reviewed, refined, and moved forward.

After: Keep the Momentum

Send a quick follow-up thanking everyone for their time and creativity. Reinforce that this is just the beginning. More to come!

With help from your volunteers, capture all ideas in a shared document, tally votes, and define next steps:

1. Share the summary docs so everyone can reflect.
2. Gather feedback and invite additional thoughts.
3. Assess impact vs. effort for each idea.
4. Engage leadership and sponsors to get buy-in for promising ideas.
5. Consider budget and resources early.
6. Identify project champions. Not idea owners, but people who can move ideas forward and build teams.
7. Create teams around high-potential ideas. Make sure to include those who were passionate about them.
8. Plan follow-up sessions for refinement and move toward official project initiatives.

Conclusion

With a little preparation and clear expectations, you can take brainstorming sessions to the next level. You prime the pump for real creativity when your team understands the goal and the process. Pair these concepts with broader initiatives with North Star Goals.

So rally your team, break the routine, and spark some innovation!

……

If you are looking for a partner in brainstorming, reach out to your Perficient account manager or use our contact form to begin a conversation.

1. Why Modern Teams Choose GitHub

Migrating from GitLab to GitHub represents a strategic shift for many engineering teams. Organizations often move to leverage GitHub’s massive open-source community and superior third-party tool integrations. Moreover, GitHub Actions provides a powerful, modern ecosystem for automating complex developer workflows. Ultimately, this transition simplifies standardization across multiple teams while improving overall project visibility.

2. Prepare Your Migration Strategy

A successful transition requires more than just moving code. You must account for users, CI/CD pipelines, secrets, and governance to avoid data loss. Consequently, a comprehensive plan should cover the following ten phases:

• Repository and Metadata Transfer

• User Access Mapping

• CI/CD Pipeline Conversion

• Security and Secret Management

• Validation and Final Cutover

3. Execute the Repository Transfer

The first step involves migrating your source code, including branches, tags, and full commit history.

• Choose the Right Migration Tool

For straightforward transfers, the GitHub Importer works well. However, if you manage a large organization, the GitHub Enterprise Importer offers better scale. For maximum control, technical teams often prefer the Git CLI.

Command Line Instructions:

git clone –mirror gitlab_repo_url
cd repo.git
git push –mirror github_repo_url

Manage Large Files and History:

During this phase, audit your repository for large binary files. Specifically, you should use Git LFS (Large File Storage) for any assets that exceed GitHub’s standard limits.

4. Map Users and Recreate Secrets

GitLab and GitHub use distinct identity systems, so you cannot automatically migrate user accounts. Instead, you must map GitLab user emails to GitHub accounts and manually invite them to your new organization.

Secure Your Variables and Secrets:

For security reasons, GitLab prevents the export of secrets. Therefore, you must recreate them in GitHub using the following hierarchy:

• Repository Secrets: Use these for project-level variables.

• Organization Secrets: Use these for shared variables across multiple repos.

• Environment Secrets: Use these to protect variables in specific deployment stages.

5.Migrating Variables and Secrets

Securing your environment requires a clear strategy for moving CI/CD variables and secrets. Specifically, GitLab project variables should move to GitHub Repository Secrets, while group variables should be placed in Organization Secrets. Notably, secrets must be recreated manually or via the GitHub API because they cannot be exported from GitLab for security reasons.

6. Convert GitLab CI to GitHub Actions

Translating your CI/CD pipelines often represents the most challenging part of the migration. While GitLab uses a single.gitlab-ci.yml file, GitHub Actions utilizes separate workflow files in the .github/workflows/ directory.

Syntax and Workflow Changes:

When converting, map your GitLab “stages” into GitHub “jobs”. Moreover, replace custom GitLab scripts with pre-built actions from the GitHub Marketplace to save time. Finally, ensure your new GitHub runners have the same permissions as your old GitLab runners.

7.Finalize the Metadata and Cutover

Metadata like Issues, Pull Requests (Merge Requests in GitLab), and Wikis require special handling because Git itself does not track them.

The Pre-Cutover Checklist:

Before the official switch, verify the following:

1. Freeze all GitLab repositories to stop new pushes.

2. Perform a final sync of code and metadata.

3. Update webhooks for tools like Slack, Jira, or Jenkins.

4. Verify that all CI/CD pipelines run successfully.

8. Post-Migration Best Practices

After completing the cutover, archive your old GitLab repositories to prevent accidental updates. Furthermore, enable GitHub’s built-in security features like Dependabot and Secret Scanning to protect your new environment. Finally, provide training sessions to help your team master the new GitHub-centric workflow.

.

9. Final Cutover and Post-Migration Best Practices

Ultimately, once all repositories are validated and secrets are verified, you can execute the final cutover. Specifically, you should freeze your GitLab repositories and perform a final sync before switching your DNS and webhooks. Finally, once the move is complete, remember to archive your old GitLab repositories and enable advanced security features like Dependabot and secret scanning.

10.Summary and Final Thoughts

In conclusion, a GitLab to GitHub migration is a significant but rewarding effort. By following a structured plan that includes proper validation and team training, organizations can achieve a smooth transition. Therefore, with the right tooling and preparation, you can successfully improve developer productivity and cross-team collaboration

Introduction

When I started investigating the React Native upgrade from 0.72.7 to 0.82, my initial goal was simple:  

Check breaking changes and library compatibility. But very quickly, I realized this upgrade was not just a version bump. It was deeply tied to React Native’s New Architecture, especially Fabric UI Engine and TurboModules.  This blog shares what I discovered, what changed internally, and why this upgrade matters in real-world apps, not just release notes. 

Why I Started Digging Deeper  

At first glance:  

• The app was already stable 
• Performance was “acceptable” 
• Most screens worked fine

Why should we even care about Fabric and TurboModules while upgrading?

The answer became clear when I compared how React Native worked internally in 0.72.7 vs 0.82. 

The Reality in React Native 0.72.7 (Old Architecture) 

In 0.72.7, even though the New Architecture existed, most apps were still effectively running on the old bridge model. 

What I Observed 

• UI updates were asynchronous 
• JS → Native communication relied on serialized messages 
• Native modules were eagerly loaded 
• Startup time increased as the app grew 

Performance issues appeared under: 

• Heavy animations 
• Large FlatLists 
• Complex navigation stacks 

None of these were “bugs” they were architectural limitations. 

What Changed in React Native 0.82 

By the time I reached 0.82, it was clear that Fabric and TurboModules were no longer optional concepts they were becoming the default future. The upgrade forced me to understand why React Native was redesigned internally. 

My Understanding of Fabric UI Engine (After Investigation) 

Fabric is not just a rendering upgrade it fundamentally changes how UI updates happen. 

What Changed Compared to 0.72.7

Synchronous UI Updates

Earlier: 

• UI updates waited for the JS bridge 

With Fabric: 

• UI updates can happen synchronously 
• JS and Native talk directly through JSI 
• Result: noticeably smoother interactions 

This became obvious in: 

• Gesture-heavy screens 
• Navigation transitions 
• Scroll performance 

Shared C++ Core

While upgrading, I noticed Fabric uses a shared C++ layer between: 

• JavaScript 
• iOS 
• Android 

This reduces: 

• Data duplication 
• Platform inconsistencies 
• Edge-case UI bugs 

From a maintenance point of view, this is huge. 

Better Support for Concurrent Rendering

Fabric is built with modern React features in mind. 

That means: 

• Rendering can be interrupted 
• High-priority UI updates are not blocked 
• Heavy JS work doesn’t freeze the UI 

In practical terms: 

The app feels more responsive, even when doing more. TurboModules: The Bigger Surprise for Me, I initially thought TurboModules were just an optimization. After digging into the upgrade docs and native code, I realized they solve multiple real pain points I had faced earlier. 

What I Faced in 0.72.7 

• All native modules are loaded at startup 
• App launch time increased as features grew 
• Debugging JS Native mismatches was painful 
• Weak type safety caused runtime crashes 

What TurboModules Changed:

Lazy Loading by Default

With TurboModules: 

• Native modules load only when accessed 
• Startup time improves automatically 
• Memory usage drops 

This alone makes a big difference in large apps. 

Direct JS Native Calls (No Bridge)

TurboModules use JSI instead of the old bridge. 

That means: 

• No JSON serialization 
• No async message queue 
• Direct function calls 

From a performance perspective, this is a game-changer. 

Stronger Type Safety

Using codegen, the interface between JS and Native becomes: 

• Explicit 
• Predictable 
• Compile-time safe 

Fabric + TurboModules Together (The Real Upgrade) 

What I realized during this migration is: 

Fabric and TurboModules don’t shine individually they shine together.  

My Final Take After the Upgrade Investigation 

Upgrading from 0.72.7 to 0.82 made one thing very clear to me: 

This is not about chasing versions. This is about adopting a new foundation. 

 Fabric and TurboModules: 

• Remove long-standing architectural bottlenecks 
• Make React Native feel closer to truly native apps 
• Prepare apps for future React features 
• Reduce hidden performance debt 

If someone asks me now: 

“Is the New Architecture worth it?” 

My answer is simple: 

If you care about performance, scalability, and long-term maintenance yes, absolutely. 

Perficient is recognized in Forrester’s Salesforce Consulting Services Landscape, Q4 2025, which notes our North America geographic focus and industry focus in Financial Services, Healthcare, and Manufacturing. Forrester asked each provider included in the Landscape to select the top business scenarios for which clients select them and from there determined which are the extended business scenarios that highlight differentiation among the providers. Perficient is shown in the report for having selected Agentforce, Data 360 (Data Cloud), and Industry Clouds as top reasons clients work with us out of those extended business scenarios. Our proven capabilities across Agentforce, Data 360 (Data Cloud), and Industry Clouds help clients achieve measurable outcomes from their Salesforce investments.

We believe this recognition underscores what leading analysts and buyers already know: the next phase of Salesforce is not about bigger projects—it’s about faster proof of value. The partners that win are the ones who shorten time to outcomes, orchestrate across your stack, and help you spend smarter.

How Perficient Turns Insight into Action: Our Outcomes Playbook

Outcome‑first framing becomes practical when the first milestone is small and meaningful. For revenue teams, that might be a lift in qualified pipeline from cleaner data and guided selling. For service teams, it could be faster resolution through better case routing and knowledge. For operations, it may be a reliable view of performance from harmonized data. Each path is sized to prove value quickly, then expanded as results compound.

“In this cycle, leaders want outcomes they can measure, not more complexity. The fastest path is built on proven accelerators, orchestrated workflows, and responsible AI that aligns to business goals.”
— Megan Glasow, Managing Director, Perficient’s Salesforce Practice

The Uncomfortable Truth

Most teams already “have Salesforce,” yet value stalls in the maze of customizations, parallel orgs, and integrations that never quite talk to each other. The market itself has moved from first deployments to modernization and multi-cloud expansion, which is why traditional, effort‑heavy engagements are delivering diminishing returns. Buyers are asking for partners who can deliver outcomes in increments, with industry IP and operating‑model rigor, not just more bodies.

What Changed, Practically Speaking

Two forces converged. First, core implementation work is easier to standardize, which drives commoditization. Second, AI is now embedded across the platform, including agentic capabilities that can act on your data and processes. That combination rewards teams that fix foundations, make workflows interoperable, and apply AI with governance and observability. When those pieces are in place, outcomes compound quickly.

Three Moves to Make this Quarter

1) Pick one outcome, not five

Choose a business metric that executives care about and design a sprint around it. Example outcomes: faster case resolution in Service, higher conversion in Sales, or lower cost to serve in Commerce. Anchor on a single use case, then use accelerators and standard patterns to get live in weeks. This approach mirrors how leading buyers evaluate providers today, with incremental value and industry use cases as selection criteria.

Quick start checklist:

• One KPI that is visible to the business
• A standard pattern or accelerator to reduce custom build time
• A simple adoption plan with role clarity and feedback loops

2) Orchestrate, do not bolt on

Real value shows up when workflows span systems. Map an end‑to‑end process across Salesforce and your adjacent platforms, then eliminate the handoffs that slow customers down. Expect your partner to bring reference architectures and integration patterns that make the process portable and resilient. Forrester’s guidance is explicit on this point: buyers want orchestrated workflows across tech stacks for true transformation.

3) Make ROI Repeatable

Set a cadence for license alignment, customization reduction, and tech debt cleanup. Consolidate orgs where the business case is clear. Replace custom objects with native capabilities when possible. Tie every change to operating cost, agility, or customer outcomes.

How to Choose a Partner without a 50‑page RFP

Ask three questions that cut through the noise:

• Can you show the intersection of your skills for my use case?
• What will you deliver first, and how will we measure it?
• What guardrails will be in place on day one?

Perficient’s POV: The Bottom Line

We show the intersection of our skills for your exact use case, deliver a working release tied to a single KPI in the initial increment, and put governance and auditability in place from day one. The result is measurable value, clarity on what to scale next, and confidence that outcomes will keep improving with each iteration.

If your 2026 goals include faster time to value, better orchestration, and disciplined ROI, book a modernization strategy session with our team. We will assess your current org, identify quick wins, and design an incremental plan aligned to your outcomes. Then move from strategy to proof in Outcome Over Effort, Part 2: Build, Govern, Measure, where we walk through a simple operating model to get one agent live, protect accuracy and access, and show measurable lift you can expand.

Next month’s webinar features insights from guest speakers, Forrester’s Kate Leggett and Salesforce’s Kaylin Voss, on outcomes, orchestration, and responsible AI. Bookmark this page and check back next month for details.

Forrester does not endorse any company, product, brand, or service included in its research publications and does not advise any person to select the products or services of any company or brand based on the ratings included in such publications. Information is based on the best available resources. Opinions reflect judgment at the time and are subject to change. For more information, read about Forrester’s objectivity  here .

We’re excited to announce that Perficient has been included in the “DEOT Services Provider with Other IT Services” category in the IDC Market Glance: Digital Engineering and Operational Technology Services, 4Q25 report (Doc# US53142225, December 2025). This segment includes service providers whose offerings and value proposition are focused primarily on Digital Engineering and OT services.

We believe our inclusion in this Market Glance reflects our deep commitment to helping organizations navigate the complex intersection of digital innovation and operational technology with confidence, agility, and cutting-edge engineering capabilities.

According to IDC, Digital Engineering and Operational Technology Services encompass three critical areas: product engineering services that support an enterprise’s existing software, hardware, and semiconductor product lifecycle from concept to end of life; operational technology services including plant engineering, manufacturing engineering services, asset modernization, and IIoT services; and digital engineering innovation accelerator services that leverage next-generation technologies like IoT, AI/ML, Generative AI, AR/VR, Digital Twins, Robotics, and more to transform product engineering and operational technology capabilities.

To us, this inclusion validates Perficient’s comprehensive approach to digital engineering and our ability to integrate emerging technologies with operational excellence to drive measurable business outcomes for our clients.

“Being included in the IDC Market Glance for Digital Engineering and Operational Technology Services is a testament to our team’s expertise in bridging the gap between digital innovation and operational reality,” said Justin Huckins, Perficient Director, AI Digital and Martech Strategy. “We’re proud to help organizations modernize their product engineering capabilities, optimize their operational technology infrastructure, and leverage AI and other advanced technologies to accelerate innovation and drive competitive advantage.”

Solutions Informed by Industry Expertise

We have found that one of the keys to real impact is to deeply understand the challenges and complexities of the industry for which digital engineering and operational technology solutions are created. This approach is especially important for complex manufacturing environments, energy infrastructure, and automotive innovation where off-the-shelf solutions fall short.

We believe our automotive expertise has been further validated by our inclusion as a Major Player in the IDC MarketScape: Worldwide IT and Engineering Services for Software-Defined Vehicles 2025 Vendor Assessment (Doc # US51813124, September 2025). We believe this recognition underscores our leadership in strategic vision for the automotive industry and our AI-first approach across the SDV lifecycle, promoting innovation in areas such as digital twins, augmented and virtual reality, smart personalization throughout the buyer and ownership experience, and the monetization of connected vehicle data.

Ingesting, Reporting, and Monetizing Telemetry Data

We helped a top Japanese multinational automobile manufacturer build a comprehensive cloud data platform to securely store, orchestrate, and analyze proprietary electric vehicle battery data for strategic decision-making and monetization. By designing and implementing a Microsoft Azure architecture using Terraform, we delivered robust data pipelines that clean, enrich, and ingest complex telematics datasets. Our solution integrated Databricks for advanced analytics and Power BI for visualization, creating a centralized, secure, and scalable platform that leverages data governance and strategy to maximize the monetization of EV batteries.

Explore our strategic position on battery passports and Cloud capabilities.

Transforming EV Adoption Through Subscription Model Innovation

We partnered with a major automotive manufacturer to enhance their EV subscription plan and mobile app, addressing customer concerns about charging accessibility and infrastructure fragmentation. Our application modernization and Adobe teams created seamless customer journeys that enabled subscribers to order complimentary supercharger adapters and integrated the mobile app with shipping and billing systems to track adapter delivery and process charging transactions. This innovative approach resulted in over 105,000 adapter orders and 55,000 new subscribers in the first month of launch, generating significant media attention as the industry’s first offering of this type.

Read more about our automotive industry solutions or discover our application modernization services.

Building Advanced Metering Infrastructure for Operational Excellence

We developed an advanced metering infrastructure solution for a leading nationwide diversified energy provider to provide real-time outage information from meters, routers, transformers, and substations. Using Databricks on Azure integrated with ArcGIS and Azure API Management, we built a comprehensive data foundation to ingest IoT data from all network components while overlaying hyperspectral imagery to visualize vegetation, poles, and terrain. This AMI implementation created a single source of truth for operational teams, reduced operational costs, and enabled accurate, timely information delivery to customers, fundamentally improving maintenance, engineering, and customer service workflows.

Read more about our energy and utilities expertise or explore our IoT and operational technology capabilities.

Let’s Engineer the Future Together

As organizations continue to digitally transform their engineering and operational capabilities, Perficient remains a trusted partner for companies seeking to lead in the era of smart products, connected operations, and AI-driven innovation.

Learn more about how Perficient is shaping the future of digital engineering and operational technology.

About IDC Market Glance:

This IDC study is a vendor assessment of the 2025 IT and engineering services market for software-defined vehicles (SDVs) using the IDC MarketScape model. This assessment discusses both the quantitative and qualitative characteristics for success in the software-defined vehicle life-cycle services market and covers a variety of vendors operating in this market. The evaluation is based on a comprehensive and rigorous framework that compares vendors, assesses them based on certain criteria, and highlights the factors expected to be most important for market success in the short and long terms.