Looking back on our first-ever Women in Digital Breakfast at Sitecore Symposium, we had an inspiring and impactful gathering focused on empowerment, leadership, and allyship in the digital industry. The goal was to celebrate the achievements of women and provide a platform for them to share their thoughts and experiences from an industry that is constantly evolving.

Featured Speakers:

• Moderator: Megan Mueller Jensen, Portfolio Specialist, Perficient
• Panelist: Kathie Johnson, Chief Marketing Officer, Sitecore​
• Panelist: Ashley Spiro, Global Head of Website Factory
• Panelist: Elycia Arendt, Director of Application Development, National Marrow Donor Program

There was no shortage of meaningful discussions during the event. Below are a few of the memorable moments and key takeaways from our panelists about the importance of allyship, redefining success, and practical steps for change.

Watch the Highlights

1. Allyship Matters

While the event celebrated women in digital, the presence of male allies who attended was emphasized as crucial to progress. Supporting female colleagues, amplifying their voices, and advocating for inclusivity are key actions that drive real change.

2. Creating a More Equitable Workplace

Panelists highlighted the importance of supporting women in leadership roles and rethinking hiring and promotion practices, showing that challenging existing processes is both necessary and valuable. Simple yet powerful changes such as ensuring diverse interview pools and fostering mentorship can make a lasting impact.

3. The Power of Community and Giving Back

Instead of traditional event swag, donations were made on behalf of those in attendance to the American Cancer Society in recognition of Breast Cancer Awareness Month. This gesture reinforced the importance of purpose-driven initiatives in the corporate space while supporting and championing the women in our lives who have been impacted by breast cancer.

4. Reshaping Definitions of Success

Success isn’t just about titles and promotions but about making an impact. Our panelists shared how their definition of success has evolved, highlighting the importance of fulfillment, mentorship, and work-life balance. They emphasized the power of leadership that inspires and supports others, encouraging professionals to be the kind of managers they once wished for in their own careers.

5. Supporting Women Re-Entering the Workforce

The pandemic had a disproportionate impact on women, many of whom were forced to leave the workforce to care for children, aging parents, or other relatives. Technology provides a strong opportunity for these individuals to re-enter the workforce and companies should make a concerted effort to actively welcome and support returning women, offering flexibility and resources to help them succeed.

6. Authenticity and Confidence in Leadership

Women frequently hesitate to take credit for their achievements, often downplaying their success. This underscores the need for cultural change that encourages women to confidently own their accomplishments and push for equal recognition. Our panelists encouraged attendees to own their success, advocate for themselves, and challenge outdated perceptions of leadership. Women need to take up space and be proud of what they’ve achieved while also acknowledging the contributions of others.

7. Practical Steps for Change

Attendees were urged to take tangible actions, such as:

• Speaking up for female colleagues, whether they are present or not.
• Encouraging women to apply for leadership roles.
• Recognizing and addressing unconscious biases in hiring and promotions.
• Offering flexibility to caregivers and parents.

Our panel served as a powerful reminder that collective efforts can drive meaningful change. By fostering inclusivity and championing one another, we can shape a more equitable and dynamic digital industry.

We look forward to seeing you at our next Women in Digital panel at Sitecore Symposium 2025 in Orlando!

In today’s rapidly evolving healthcare landscape, artificial intelligence (AI) and generative AI are no longer just buzzwords – they’re transformative technologies reshaping how we deliver care, manage operations, and drive innovation. As healthcare organizations navigate this complex technological frontier, establishing an Analytics Center of Excellence (ACoE) focused on AI and generative AI has become crucial for sustainable success and competitive advantage.

The Evolution of Analytics in Healthcare

Healthcare organizations are sitting on vast treasures of data – from electronic health records and medical imaging to claims data and operational metrics. However, the real challenge lies not in data collection but in transforming this data into actionable insights that drive better patient outcomes and operational efficiency. This is where an AI-focused ACoE becomes invaluable.

Core Components of an AI-Driven Healthcare ACoE

1. People: Building a Multidisciplinary Team of Experts

The foundation of any successful ACoE is its people. For healthcare AI initiatives, the team should include:

• Clinical AI Specialists: Healthcare professionals with deep domain knowledge and AI expertise
• Data Scientists & ML Engineers: Experts in developing and deploying AI/ML models
• Healthcare Data Engineers: Specialists in healthcare data architecture and integration
• Clinical Subject Matter Experts: Physicians, nurses, and healthcare practitioners
• Ethics & Compliance Officers: Experts in healthcare regulations and AI ethics
• Business Analysts: Professionals who understand healthcare operations and analytics
• Change Management Specialists: Experts in driving organizational adoption
• UI/UX Designers: Specialists in creating intuitive healthcare interfaces

2. Processes: Establishing Robust Frameworks

The ACoE should implement clear processes aligned with the PACE framework:

Policies:
– Data governance and privacy frameworks (HIPAA, GDPR, etc.)
– AI model development and validation protocols
– Clinical validation procedures
– Ethical AI guidelines
– Regulatory compliance processes

Advocacy:
– Stakeholder engagement programs
– Clinical adoption initiatives
– Training and education programs
– Internal communication strategies
– External partnership management

Controls:
– Model risk assessment frameworks
– Clinical outcome validation
– Performance monitoring systems
– Quality assurance protocols
– Audit mechanisms

Enablement:
– Resource allocation frameworks
– Technology adoption protocols
– Innovation pipeline management
– Knowledge sharing systems
– Collaboration platforms

3. Technology: Implementing a Robust Technical Infrastructure

The well-designed technical foundation of the ACoE should include:

Core Infrastructure:
– Cloud computing platforms (with healthcare-specific security features)
– Healthcare-specific AI/ML platforms
– Data lakes and warehouses optimized for healthcare data
– Model development and deployment platforms
– Integration engines for healthcare systems

AI/ML Capabilities:
– Natural Language Processing for clinical documentation
– Computer Vision for medical imaging
– Predictive analytics for patient outcomes
– Generative AI for medical research and content creation
– Real-time analytics for operational efficiency

Security & Compliance:
– End-to-end encryption
– Access control systems
– Audit logging mechanisms
– Compliance monitoring tools
– Privacy-preserving AI techniques

4. Economic Evaluation: Measuring Financial Impact

The ACoE should establish clear metrics for measuring the economic impact of the initiative:

Cost Metrics:
– Implementation costs
– Operational expenses
– Training and development costs
– Infrastructure investments
– Licensing and maintenance fees

Benefit Metrics:

• Utilization of health services (e.g., reduced ER and acute inpatient utilization for chronic conditions)
• Revenue enhancement
• Cost reduction
• Efficiency gains (e.g., faster triage, and patient discharge times; shorter waiting times)
• Quality improvements
• Market share growth

5. Key Performance Indicators (KPIs)

Establish comprehensive KPIs across multiple dimensions:

Clinical Impact:
– Patient outcome improvements
– Reduction in medical errors
– Length of stay optimization
– Readmission rate reduction
– Clinical decision support effectiveness

Operational Efficiency:
– Process automation rates
– Resource utilization
– Workflow optimization
– Staff productivity
– Cost per patient

Innovation Metrics:
– Number of AI models deployed
– Model accuracy and performance
– Time to deployment
– Innovation pipeline health
– Research publications and patents

User Adoption:
– System utilization rates
– User satisfaction scores
– Training completion rates
– Feature adoption metrics
– Feedback implementation rate

6. Outcomes: Delivering Measurable Results

Focus on achieving and documenting concrete outcomes:

Patient Care:
– Improved diagnostic accuracy
– Enhanced treatment planning
– Better patient and clinician engagement
– Reduced medical errors
– Improved patient and provider satisfaction

Operational Excellence:
– Streamlined workflows
– Reduced administrative burden
– Better resource allocation
– Improved cost management
– Enhanced regulatory compliance

Innovation Leadership:
– New AI-driven solutions
– Research contributions
– Industry recognition
– Competitive advantage
– Market leadership

Implementation Roadmap

1. Foundation Phase (0-6 months)
– Establish governance structure
– Build core team
– Define initial use cases
– Set up basic infrastructure

2. Development Phase (6-12 months)
– Implement initial AI projects
– Develop training programs
– Create documentation frameworks
– Establish monitoring systems

1. Scaling Phase (12-24 months)

– Expand use cases
– Enhance capabilities
– Optimize processes
– Measure and adjust

Ensuring Success: Critical Success Factors

1. Executive Sponsorship
– Clear leadership support
– Resource commitment
– Strategic alignment
– Change management

2. Stakeholder Engagement
– Clinical staff involvement
– IT team collaboration
– Patient feedback
– Partner participation

3. Continuous Learning
– Regular training
– Knowledge sharing
– Best practice updates
– Industry monitoring

Conclusion

Building an AI-focused Analytics Center of Excellence in healthcare is a complex but rewarding journey. Success requires careful attention to people, processes, technology, and outcomes. By following this comprehensive framework and maintaining a steadfast focus on delivering value, healthcare organizations can build an ACoE that drives innovation, improves patient care, and creates sustainable competitive advantage.

The future of healthcare lies in our ability to harness the power of AI and analytics effectively. A well-designed ACoE serves as a scalable and flexible foundation for this transformation, enabling organizations to compete on analytics and thrive in an increasingly data-driven healthcare landscape.

In this blog post, I will share my journey of implementing an automated solution to publish release notes for service deployments to Confluence using Bitbucket Pipelines. This aimed to streamline our release process and ensure all relevant information was easily accessible to our team. By leveraging tools like Bitbucket and Confluence, we achieved a seamless integration that enhanced our workflow.

Step 1: Setting Up the Pipeline

We configured our Bitbucket pipeline to include a new step for publishing release notes. This involved writing a script in the bitbucket-pipelines.yml file to gather the necessary information (SHA, build number, and summary of updates).

Step 2: Generating Release Notes

We pulled the summary of updates from our commit messages and release notes. To ensure the quality of the summaries, we emphasized the importance of writing detailed and informative commit messages.

Step 3: Publishing to Confluence

Using the Confluence Cloud REST API, we automated the creation of Confluence pages. We made a parent page titled “Releases” and configured the script to publish a new page.

Repository Variables

We used several repository variables to keep sensitive information secure and make the script more maintainable:

• REPO_TOKEN: The token used to authenticate with the Bitbucket API.
• CONFLUENCE_USERNAME: The username for Confluence authentication.
• CONFLUENCE_TOKEN: The token for Confluence authentication.
• CONFLUENCE_SPACE_KEY: The key to the Confluence space where the release notes are published.
• CONFLUENCE_ANCESTOR_ID: The ID of the parent page under which new release notes pages are created.
• CONFLUENCE_API_URL: The URL of the Confluence API endpoint.

Script Details

Here is the script we used in our bitbucket-pipelines.yml file, along with an explanation of each part:

Step 1: Define the Pipeline Step

- step: &release-notes
      name: Publish Release Notes
      image: atlassian/default-image:3

• Step Name: The step is named “Publish Release Notes”.
• Docker Image: Uses the atlassian/default-image:3 Docker image for the environment.

Step 2: List Files

script:
  - ls -la /src/main/resources/

• List Files: The ls -la command lists the files in the specified directory to ensure the necessary files are present.

Step 3: Extract Release Number

- RELEASE_NUMBER=$(grep '{application_name}.version' /src/main/resources/application.properties | cut -d'=' -f2)

• Extract Release Number: The grep command extracts the release number from the application.properties file where the property {application_name}.version should be present.

Step 4: Create Release Title

- RELEASE_TITLE="Release - $RELEASE_NUMBER Build- $BITBUCKET_BUILD_NUMBER Commit- $BITBUCKET_COMMIT"

• Create Release Title: Construct the release title using the release number, Bitbucket build number, and commit SHA.

Step 5: Get Commit Message

- COMMIT_MESSAGE=$(git log --format=%B -n 1 ${BITBUCKET_COMMIT})

• Get Commit Message: The git log command retrieves the commit message for the current commit.

Step 6: Check for Pull Request

- |
  if [[ $COMMIT_MESSAGE =~ pull\ request\ #([0-9]+) ]]; then
    PR_NUMBER=$(echo "$COMMIT_MESSAGE" | grep -o -E 'pull\ request\ \#([0-9]+)' | sed 's/[^0-9]*//g')

• Check for Pull Request: The script checks if the commit message contains a pull request number.
• Extract PR Number: If a pull request number is found, it is extracted using grep and sed.

Step 7: Fetch Pull Request Description

RAW_RESPONSE=$(wget --no-hsts -qO- --header="Authorization: Bearer $REPO_TOKEN" "https://api.bitbucket.org/2.0/repositories/$BITBUCKET_WORKSPACE/$BITBUCKET_REPO_SLUG/pullrequests/${PR_NUMBER}")
PR_DESCRIPTION=$(echo "$RAW_RESPONSE" | jq -r '.description')
echo "$PR_DESCRIPTION" > description.txt

• Fetch PR Description: Uses wget to fetch the pull request description from the Bitbucket API.
• Parse Description: Parses the description using jq and saves it to description.txt.

Step 8: Prepare JSON Data

 AUTH_HEADER=$(echo -n "$CONFLUENCE_USERNAME:$CONFLUENCE_TOKEN" | base64 | tr -d '\n')
 JSON_DATA=$(jq -n --arg title "$RELEASE_TITLE" \
                    --arg type "page" \
                    --arg space_key "$CONFLUENCE_SPACE_KEY" \
                    --arg ancestor_id "$CONFLUENCE_ANCESTOR_ID" \
                    --rawfile pr_description description.txt \
                    '{
                      title: $title,
                      type: $type,
                      space: {
                        key: $space_key
                      },
                      ancestors: [{
                        id: ($ancestor_id | tonumber)
                      }],
                      body: {
                        storage: {
                          value: $pr_description,
                          representation: "storage"
                        }
                      }
                    }')
  echo "$JSON_DATA" > json_data.txt

• Prepare Auth Header: Encodes the Confluence username and token for authentication.
• Construct JSON Payload: Uses jq to construct the JSON payload for the Confluence API request.
• Save JSON Data: Saves the JSON payload to json_data.txt.

Step 9: Publish to Confluence

  wget --no-hsts --method=POST --header="Content-Type: application/json" \
      --header="Authorization: Basic $AUTH_HEADER" \
      --body-file="json_data.txt" \
      "$CONFLUENCE_API_URL" -q -O -
  if [[ $? -ne 0 ]]; then
    echo "HTTP request failed"
    exit 1
  fi

• Send POST Request: This method uses wget to send a POST request to the Confluence API to create or update the release notes page.
• Error Handling: Checks if the HTTP request failed and exits with an error message if it did.

Script

# Service for publishing release notes
- step: &release-notes
      name: Publish Release Notes
      image: atlassian/default-image:3
      script:
        - ls -la /src/main/resources/
        - RELEASE_NUMBER=$(grep '{application_name}.version' /src/main/resources/application.properties | cut -d'=' -f2)
        - RELEASE_TITLE="Release - $RELEASE_NUMBER Build- $BITBUCKET_BUILD_NUMBER Commit- $BITBUCKET_COMMIT"
        - COMMIT_MESSAGE=$(git log --format=%B -n 1 ${BITBUCKET_COMMIT})
        - |
          if [[ $COMMIT_MESSAGE =~ pull\ request\ #([0-9]+) ]]; then
            PR_NUMBER=$(echo "$COMMIT_MESSAGE" | grep -o -E 'pull\ request\ \#([0-9]+)' | sed 's/[^0-9]*//g')
            RAW_RESPONSE=$(wget --no-hsts -qO- --header="Authorization: Bearer $REPO_TOKEN" "https://api.bitbucket.org/2.0/repositories/$BITBUCKET_WORKSPACE/$BITBUCKET_REPO_SLUG/pullrequests/${PR_NUMBER}")
            PR_DESCRIPTION=$(echo "$RAW_RESPONSE" | jq -r '.description')
            echo "$PR_DESCRIPTION" > description.txt
            AUTH_HEADER=$(echo -n "$CONFLUENCE_USERNAME:$CONFLUENCE_TOKEN" | base64 | tr -d '\n')
            JSON_DATA=$(jq -n --arg title "$RELEASE_TITLE" \
                              --arg type "page" \
                              --arg space_key "$CONFLUENCE_SPACE_KEY" \
                              --arg ancestor_id "$CONFLUENCE_ANCESTOR_ID" \
                              --rawfile pr_description description.txt \
                              '{
                                title: $title,
                                type: $type,
                                space: {
                                  key: $space_key
                                },
                                ancestors: [{
                                  id: ($ancestor_id | tonumber)
                                }],
                                body: {
                                  storage: {
                                    value: $pr_description,
                                    representation: "storage"
                                  }
                                }
                              }')
            echo "$JSON_DATA" > json_data.txt
            wget --no-hsts --method=POST --header="Content-Type: application/json" \
              --header="Authorization: Basic $AUTH_HEADER" \
              --body-file="json_data.txt" \
              "$CONFLUENCE_API_URL" -q -O -
            if [[ $? -ne 0 ]]; then
              echo "HTTP request failed"
              exit 1
            fi
          fi

Outcomes and Benefits

• The automation significantly reduced the manual effort required to publish release notes.
• The project improved our overall release process efficiency and documentation quality.

Conclusion

Automating the publication of release notes to Confluence using Bitbucket Pipelines has been a game-changer for our team. It has streamlined our release process and ensured all relevant information is readily available. I hope this blog post provides insights and inspiration for others looking to implement similar solutions.

SAP Databricks is important because convenient access to governed data to support business initiatives is important. Breaking down silos has been a drumbeat of data professionals since Hadoop, but this SAP <-> Databricks initiative may help to solve one of the more intractable data engineering problems out there. SAP has a large, critical data footprint in many large enterprises. However, SAP has an opaque data model.  There was always a long painful process to do the glue work required to move the data while recognizing no real value was being realized in that intermediate process. This caused a lot of projects to be delayed, fail, or not pursued resulting in a pretty significant lost opportunity cost for the client and a potential loss of trust or confidence in the system integrator. SAP recognized this and partnered with a small handful of companies to enhance and enlarge the scope of their offering. Databricks was selected to deliver bi-directional integration with their Databricks Lakehouse platform. When I heard there was going to be a big announcement, I thought we were going to hear about a new Lakehouse Federation Connector. That would have been great; I’m a fan.

This was bigger.

Technical details are still emerging, so I’m going to try to focus on what I heard and what I think I know. I’m also going to hit on some use cases that we’ve worked on that I think could be directly impacted by this today. I think the most important takeaway for data engineers is that you can now combine SAP with your Lakehouse without pipelines. In both directions. With governance. This is big.

SAP Business Data Cloud

I don’t know much about SAP, so you can definitely learn more here. I want to understand more about the architecture from a Databricks perspective and I was able to find out some information from the Introducing SAP Databricks post on the internal Databricks blog page.

This is when it really sunk in that we were not dealing with a new Lakeflow Connector; SAP Databricks is a native component in the SAP Business Data Cloud and will be sold by SAP as part of their SAP Business Data Cloud offering. It’s not in the diagram here, but you can actually integrate new or existing Databricks instances with SAP Databricks. I don’t want to get ahead of myself, but I would definitely consider putting that other instance of Databricks on another hyperscaler. In my mind, the magic is the dotted line from the blue “Curated context-rich SAP data products” up through the Databricks stack.

Open Source Sharing

The promise of SAP Databricks is the ability to easily combine SAP data with the rest of the enterprise data. In my mind, easily means no pipelines that touch SAP. The diagram we see with the integration point between SAP and Databricks SAP uses Delta Sharing as the underlying enablement technology.

Delta Sharing is an open-source protocol, developed by Databricks and the Linux Foundation, that provides strong governance and security for sharing data, analytics and AI across internal business units, cloud providers and applications. Data remains in its original location with Delta Sharing: you are sharing live data with no replication. Delta Share, in combination with Unity Catalog, allows a provider to grant access to one or more recipients and dictate what data can be seen by those shares using row and column-level security.

Open Source Governance

Databricks leverages Unity Catalog for security and governance across the platform including Delta Share. Unity Catalog offers strong authentication, asset-level access control and secure credential vending to provide a single, unified, open solution for protecting both (semi- & un-)structured data and AI assets. Unity Catalog offers a comprehensive solution for enhancing data governance, operational efficiency, and technological performance. By centralizing metadata management, access controls, and data lineage tracking, it simplifies compliance, reduces complexity, and improves query performance across diverse data environments. The seamless integration with Delta Lake unlocks advanced technical features like predictive optimization, leading to faster data access and cost savings. Unity Catalog plays a crucial role in machine learning and AI by providing centralized data governance and secure access to consistent, high-quality datasets, enabling data scientists to efficiently manage and access the data they need while ensuring compliance and data integrity throughout the model development lifecycle.

Data Warehousing

Databricks is now a first-class Data Warehouse with its Databricks SQL offering. The serverless SQL warehouses have been kind of a game changer for me because they spin up immediately and size elastically. Pro tip: now is a great time to come up with a tagging strategy. You’ll be able to easily connect your BI tool (Tableau, PowerBI, etc) to the warehouse for reporting. There are also a lot of really useful AI/BI opportunities available natively now. If you remember in the introduction, I said that I would have been happy had this only been a Lakehouse Federation offering. You still have the ability to take advantage of Federation to discover, query and govern data from Snowflake, Redshift, Salesforce, Teradata and many others all from within a Databricks instance. I’m still wrapping my head around being able to query Salesforce and SAP Data in a notebook inside Databricks inside SAP.

Mosaic AI + Joule

As a data engineer, I was the most excited about zero-copy, bi-directional SAP data flow into Databricks. This is selfish because it solves my problems, but its relatively short-sighted. The integration between SAP and Databricks will likely deliver the most value through Agentic AI. Lets stipulate that I believe that chat is not the future of GenAI. This is not a bold statement; most people agree with me. Assistants like co-pilots represented a strong path forward. SAP thought so, hence Joule. It appears that SAP is leveraging the Databricks platform in general and MosaicAI in particular to provide a next generation of Joule which will be an AI copilot infused with agents.

In the ever-evolving landscape of web development, choosing the right framework can significantly impact the performance and user experience of your applications. Two of the most prominent frameworks in the React ecosystem today are Remix and Next.js. Both are designed to enhance web development efficiency and performance, but they cater to different needs and use cases. In this blog, we’ll explore the strengths, features, and considerations of each framework to help you make an informed decision.

What is Remix?

Remix is an edge-native, full-stack JavaScript framework that focuses on building modern, fast, and resilient user experiences. It acts primarily as a compiler, development server, and a lightweight server runtime for react-router. This unique architecture allows Remix to deliver dynamic content efficiently, making it particularly well-suited for applications that require real-time updates and high interactivity.

Key Features of Remix:

• Dynamic Content Delivery: Remix excels in delivering dynamic content, ensuring that users receive the most up-to-date information quickly.
• Faster Build Times: The framework is designed for speed, allowing developers to build and deploy applications more efficiently.
• Full-Stack Capabilities: Remix supports both client-side and server-side rendering, providing flexibility in how applications are structured.
• Nested Routes: Remix uses a hierarchical routing system where routes can be nested inside each other. Each route can have its own loader (data fetching) and layout, making UI updates more efficient.
• Enhanced Data Fetching: Remix loads data on the server before rendering the page. Uses loader functions to fetch data in parallel, reducing wait times. Unlike React, data fetching happens at the route level, avoiding unnecessary API calls.
• Progressive Enhancement: Remix prioritizes basic functionality first and enhances it for better UX. Pages work even without JavaScript, making them faster and more accessible. Improves SEO, performance, and user experience on slow networks.

What is Next.js?

Next.js is a widely used React framework that offers a robust set of features for building interactive applications. It is known for its strong support for server-side rendering (SSR) and routing, making it a popular choice among developers looking to create SEO-friendly applications.

Key Features of Next.js:

• Server-Side Rendering: Next.js provides built-in support for SSR, which can improve performance and SEO by rendering pages on the server before sending them to the client.
• Extensive Community Support: With over 120,000 GitHub stars, Next.js boasts a large and active community, offering a wealth of resources, plugins, and third-party integrations.
• Automatic Static Optimization: Next.js automatically pre-renders pages as static HTML if no server-side logic is used. This improves performance by serving static files via CDN. Pages using getStaticProps (SSG) benefit the most.
• Built-in API Routes: Next.js allows you to create serverless API endpoints inside the pages/api/ directory. No need for a separate backend, it runs as a serverless function.
• Fast Refresh: Next.js Fast Refresh allows instant updates without losing component state. Edits to React components update instantly without a full reload.  Preserves state in functional components during development.
• Rich Ecosystem: The framework includes a variety of features such as static site generation (SSG), API routes, and image optimization, making it a versatile choice for many projects.

Setting Up a Simple Page

Remix Example

In Remix, you define routes based on the file structure in your app/routes directory. Here’s how you would create a simple page that fetches data from an API:

File Structure:

app/  
  └── routes/  
      └── index.tsx  

index.tsx

import { json, LoaderFunction } from '@remix-run/node';
import { useLoaderData } from "@remix-run/react";

type Item = {
  id: number;
  name: string;
};
type LoaderData = Item[];

export let loader: LoaderFunction = async () => {  
  const res = await fetch('https://api.example.com/data');  
  const data: LoaderData = await res.json();  
  return json(data);  
};  

export default function Index() {  
  const data = useLoaderData<LoaderData>();  
  
  return (  
    <div>  
      <h1>Data from API</h1>  
      <ul>  
        {data.map((item: Item) => (  
          <li key={item.id}>{item.name}</li>  
        ))}  
      </ul>  
    </div>  
  );  
}

Next.js Example

In Next.js, you define pages in the pages directory. Here’s how you would set up a similar page:

File Structure

pages/  
  └── index.js  

index.jsx

export async function getServerSideProps() {
  const res = await fetch("https://jsonplaceholder.typicode.com/posts");
  const posts = await res.json();

  return { props: { posts } }; // Pass posts array to the component
}

export default function Home({ posts }) {
  return (
    <div>
      <h1>All Posts</h1>
      <ul>
        {posts.map((post) => (
          <li key={post.id}>
            <h2>{post.title}</h2>
            <p>{post.body}</p>
          </li>
        ))}
      </ul>
    </div>
  );
}

Comparing Remix and Next.js

Data Fetching Differences

Remix

• Uses loaders to fetch data before rendering the component.
• Data is available immediately in the component via useLoaderData.

Next.js

• Uses React’s useEffect hook to fetch data after the component mounts.
• Data fetching can be done using getStaticProps or getServerSideProps for static site generation or server-side rendering, respectively.

Caching Strategies

Next.js

Next.js primarily relies on Static Generation (SSG) and Incremental Static Regeneration (ISR) for caching, while also allowing Server-Side Rendering (SSR) with per-request fetching.

Static Generation (SSG)

• Caches pages at build time and serves static HTML files via CDN.
• Uses getStaticProps() to prefetch data only once at build time.
• Best for: Blog posts, marketing pages, documentation.

Incremental Static Regeneration (ISR)

• Rebuilds static pages in the background at set intervals (without a full redeploy).
• Uses revalidate to periodically refresh the cache.
• Best for: Product pages, news articles, dynamic content with occasional updates.

Server-Side Rendering (SSR)

• Does NOT cache the response, fetches fresh data for every request.
• Uses getServerSideProps() and runs on each request.
• Best for: User-specific pages, real-time data (stock prices, dashboards).

Remix

Remix treats caching as a fundamental concept by leveraging browser and CDN caching efficiently.

 Loader-Level Caching (Response Headers)

• Remix caches API responses at the browser or CDN level using Cache-Control headers.
• Uses loader() functions for server-side data fetching, allowing fine-grained caching control.
• Best for: Any dynamic or frequently updated data.

Full-Page Caching via Headers

• Unlike Next.js, which caches only static pages, Remix caches full page responses via CDN headers.
• This means faster loads even for dynamic pages.

Browser-Level Caching (Prefetching)

• Remix automatically prefetches links before the user clicks, making navigation feel instant.
• Uses <Link> components with automatic preloading.

Performance

While both frameworks are engineered for high performance, Remix tends to offer better dynamic content delivery and faster build times. This makes it ideal for applications that require real-time updates and high interactivity.

Developer Experience

Both frameworks aim to improve the developer experience, but they do so in different ways. Remix focuses on simplifying the development process by minimizing setup and configuration, while Next.js provides a more extensive set of built-in features, which can be beneficial for larger projects.

Community and Ecosystem

Next.js has a larger community presence, which can be advantageous for developers seeking support and resources. However, Remix is rapidly gaining traction and building its own dedicated community.

Conclusion

Choosing between Remix and Next.js ultimately depends on your specific project requirements and preferences If you are looking for dynamic content delivery and quick build time, Remix might be the better option for you. But, if you need strong server-side rendering features and a rich ecosystem of tools, Next.js could be the way to go.

Both frameworks are excellent choices for modern web development, and knowing their strengths and trade-offs will help you pick the right one for your next project. No matter whether you opt for Remix or Next.js, you’ll be set to build high-performance, user-friendly applications that can tackle the challenges of today’s web.

The rapidly evolving payments industry is driving industry leaders to adapt their strategies in response to emerging trends. As technology advances and consumer expectations shift, staying ahead of these trends is crucial for success.

Payments Trend #1: AI-Driven Payment Innovations

The landscape of payments and financial services in 2025 will be marked by groundbreaking innovations and user-centric designs powered by Generative AI (GenAI). The industry faces numerous challenges, including protecting sensitive data, navigating evolving regulations, and outdated legacy systems. As these AI technologies evolve, they will transform consumer interactions with payment systems, fostering a more inclusive and sustainable financial ecosystem. This transformation will require a delicate balance between innovation and compliance, ensuring that advancements in AI contribute to a secure and efficient payments landscape.

Recommended Approach: GenAI can assist various payment processes by creating personalized and tailored payment experiences through loyalty programs, discounts, and curated product recommendations. Additionally, AI can enhance accessibility and mobile development through voice and conversational payments, improving user experience. The conversational nature of GenAI will be crucial in making transactions seamless and frictionless for consumers. To harness AI’s potential effectively, it’s essential to develop a strategy that considers payment regulations to ensure consumer protection, data privacy, and ethical use of AI. The future of payments promises not only enhanced efficiency and security but also personalized experiences that align with broader societal values.

Explore More: Transforming Industries, Powering Innovation

Payments Trend #2: The Rise of Real-Time Payments

Real-time payments in the US are expected to see widespread adoption across various sectors, driven by the integration of embedded finance, enhanced biometric authentication, and improved accessibility for consumers and businesses. Traditional payment methods like checks and ACH transfers are likely to decline, especially in business-to-business transactions. Consumers are increasingly using mobile wallets and embedded payments in non-financial platforms, while businesses are leveraging the momentum of business-to-business real-time payments facilitated by networks like FedNow. However, the payment industry encounters challenges such as user education and awareness, integration complexities across platforms and financial institutions, and ongoing regulatory considerations.

Recommended Approach: Payment companies should adopt and expand real-time payment solutions, leveraging networks like FedNow and RTP. Embracing advanced security features such as biometric authentication will enhance user experience and protect data. Ensuring inclusivity and accessibility for all consumers, including those underserved by traditional banking systems, is crucial. Additionally, businesses should explore new revenue models through premium features and address integration complexities with robust data governance and analytics. By focusing on these key areas, companies can effectively manage the challenges and opportunities presented by the widespread adoption of real-time payments.

Success In Action: Ensuring Interoperable, Compliant Real-Time Payments

Payments Trend #3: Navigating the New Regulatory Landscape

The payment industry faces drastic regulatory changes driven by the new administration. Ongoing changes to regulators, protocols, and best practices may have a lasting impact on nonbank financial companies (NBFCs), banks, fees, buy now, pay later (BNPL) services, payment apps, and digital wallets. These changes require significant adjustments in risk management, compliance frameworks, and operational protocols. Enforcing consumer protections will become a gray area, creating operational headaches for consumers and financial institutions. Additionally, the Consumer Credit Control Act (CCCA), currently under consideration, could have significant implications for payment providers. These regulatory changes impact banks and their third-party partners, requiring reassessment of partnerships and compliance strategies. Overall, companies need to adapt to these changes, leading to higher compliance costs, operational expense, and cultural shifts to thrive.

Recommended Approach:   To navigate these changes, businesses must balance innovation with compliance. AI will be pivotal in this transition, enabling automation of key compliance processes such as know your customer (KYC) and anti-money laundering (AML) checks. Additionally, AI’s capacity for real-time transaction monitoring and fraud prevention will help companies stay ahead of evolving regulatory demands.  The fintech industry, once celebrated for its agility and innovation, now faces a future shaped by heightened regulation. Leveraging AI-driven compliance solutions will be essential for managing global operations effectively in this increasingly complex landscape.

Related: 1033 Open Banking Mandate Blueprint for Success

Payments Trend #4: Optimizing Payment Orchestration Platforms

Payment orchestration platforms (POPs) are poised to play a critical role in the evolving payments landscape in 2025, driven by technological advancements, regulatory changes, and shifting consumer demands. The growth of cross-border transactions, fueled by global e-commerce expansion, necessitates platforms that can handle multiple payment methods, currencies, and compliance requirements. Advanced analytics and AI integration are becoming essential for improving transaction success rates, fraud detection, and overall business intelligence. Additionally, regulatory developments will shape the operation of POPs, aiming to enhance security and reduce fraud. Emerging regions like Asia-Pacific, Africa, and Latin America are key growth areas, with partnerships enabling access to local payment methods.

Recommended approach: To navigate this trend, payment institutions should focus on several strategies. POPs market consolidation is leading to more robust, full-stack solutions that integrate orchestration capabilities into broader platforms. Embracing advanced analytics and AI tools will be crucial for optimizing payment processes and enhancing customer experiences. Institutions should also prioritize the implementation of smart checkout experiences to improve authorization rates and streamline payment options. Staying up to date with regulatory developments and ensuring compliance with new regulations like the third(PSD3) in the EU and the role of central bank digital currencies (CBDCs) will be essential. Finally, integrating POPs with existing financial services and e-commerce platforms will modernize legacy systems and provide more seamless payment experiences, ensuring institutions remain competitive in the digital economy.

Success In Action: At the Heart of Financial Services

Payments Trend #5: The Rapid Adoption of Embedded Payments

Embedded payments are rapidly evolving, and 2025 will mark a major turning point for their adoption in the U.S. Businesses and consumers demand faster, more seamless transactions, driving the expansion of embedded payment solutions across industries. While e-commerce and fintech have been early adopters, industries such as healthcare, manufacturing, real estate, and B2B services are now integrating payment capabilities directly into their platforms. Expect more ERP systems, procurement platforms, and business management tools to embed payment functions, reducing reliance on third-party processors. As embedded payments become mainstream, U.S. regulators will tighten compliance requirements around data security, AML, and consumer protection.

Recommended Approach: Companies must meet evolving KYC and compliance standards, fostering trust and security in digital transactions. Beyond payments, businesses should integrate lending, insurance, and investment options directly into their platforms through embedded finance. Partnering with Banking as a Service (BaaS) providers will allow companies to offer customers seamless access to financial products without switching platforms, further blurring the lines between traditional banking and digital platforms. Additionally, adopting tokenized payments, stablecoins, and decentralized finance (DeFi) integrations within embedded payment systems will be crucial. With Apple Pay, Google Pay, and PayPal leading the charge, expect an increase in one-click, biometric, and voice-activated payments built into everyday digital experiences. Companies that fail to integrate seamless payment experiences risk losing customers to competitors offering faster, frictionless transactions.

You May Also Enjoy: Getting Started On Embedded Finance

Payments Trend #6: Crypto and Payments Intersect

In 2024, crypto made a strong comeback, with Bitcoin surpassing $100,000, driven by its integration into exchange-traded funds. The industry has matured, with blockchain innovations extending beyond crypto enthusiasts and into mainstream finance. Traditional financial institutions are increasingly leveraging blockchain to address complex challenges, while the U.S. continues efforts to regulate and integrate digital assets effectively. Emphasis on security, trust, and usability is essential for blockchain’s success. With these elements in place, financial institutions are embracing blockchain-based solutions, including tokenized money and assets, to enhance efficiency and reduce costs.

Recommended Approach: Companies should explore the coexistence of stablecoins and tokenized deposits. Banks are investigating tokenized deposits, blockchain-based representations of commercial deposits, to enable faster settlements and programmable payments. Meanwhile, stablecoins, pegged to fiat currency, are gaining traction in remittances and business transactions, with approximately $150 billion in circulation. A clear regulatory framework will strengthen their role, leading to an integrated system where tokenized assets and money interact seamlessly. Regulatory clarity will drive adoption, with the U.S. and EU providing models for certainty. Central banks focus on blockchain solutions for financial institutions, enhancing institutional settlements and facilitating faster cross-border capital movement. Interoperability and trust will be crucial, with institutional interest in crypto growing. The future of crypto is no longer speculative, it is becoming a fundamental part of the financial system.

See Also: Be at the Forefront of Innovation

Navigating the Road Ahead

We help payment and fintech firms innovate and boost market position with transformative digital experiences and efficient operations.

• Business Transformation: Create a roadmap to innovate products, enhance experiences, and reduce transactional risk.
• Modernization: Implement technology to improve payment processing, fraud management, and omnichannel experiences.
• Data + Analytics: Proactively leverage integrated data and AI to optimize transactions, manage fraud, and personalize experiences.
• Risk + Compliance: Enhance compliance and risk management to safeguard transactions and customer data.
• Consumer Experience: Deliver convenient, seamless experiences with user-friendly secure payment solutions.

Discover why we have been trusted by 25+ leading payments and card processing companies. Explore our financial services expertise and contact us to learn more.

Perficient is thrilled to announce its recognition as a winner in the 2024 Acquia Partner Awards for DXP Champion of the Year. This esteemed accolade highlights Perficient’s commitment to delivering superior customer outcomes, driving innovation, and achieving outstanding revenue performance within the Acquia partner ecosystem.

Acquia, a leader in open digital experience software, honored 22 organizations worldwide for their exceptional use of Acquia technologies. These awards celebrate partners who have set new standards for technical excellence by implementing high-quality solutions that help customers improve marketing outcomes and enhance business results.

“We’re honored to be recognized as Acquia’s DXP Champion & Partner of the Year! This award is a testament to the strong partnership we’ve built, working hand in hand to deliver comprehensive, end-to-end digital solutions that drive success for our clients. Together with Acquia, we’re pushing the boundaries of what’s possible in the digital experience space!” said Joshua Hover, DXP Platforms at Perficient. “We are proud to be recognized alongside such an esteemed group of partners and remain committed to advancing the digital experience landscape through our innovative solutions.”

Partner of the Year – Perficient

Perficient is a leader in DXP solutions, helping organizations modernize their platforms and drive long-term success. As one of Acquia’s first Elite Partners and a multi-year Partner of the Year award winner, we have a proven track record of delivering innovative, future-ready digital experiences. Our expertise in strategy, development, and optimization ensures our clients stay ahead in an ever-evolving digital landscape.

“At Perficient, we are dedicated to not only delivering top-tier digital solutions but also forming lasting partnerships that foster our clients’ growth and success,” said Roger Walker, Senior Business Manager of the Perficient Acquia practice. “This recognition from Acquia reinforces our commitment to aligning with our clients’ needs, helping them achieve their digital transformation goals, and driving measurable business impact.”

Acquia empowers ambitious digital innovators to craft the most productive, frictionless digital experiences that make a difference to their customers, employees, and communities. We provide the world’s leading open digital experience platform (DXP), built on open-source Drupal, as part of our commitment to shaping a digital future that is safe, accessible, and available to all. With Acquia Open DXP, you can unlock the potential of your customer data and content, accelerating time to market and increasing engagement, conversion, and revenue.

Learn more at : https://www.acquia.com/partner-of-the-year“

Application programming interfaces, or APIs, are crucial to the ever-changing digital transformation landscape because they enable businesses to interact with their data and services promptly and effectively. Effective administration is therefore necessary to guarantee that these APIs operate as intended, remain secure, and offer the intended advantages. This is where Apigee, Google Cloud’s premier API management solution, is helpful.

What is Apigee?

Apigee is an excellent tool for businesses wanting to manage their APIs smoothly. It simplifies the process of creating, scaling, securing, and deploying APIs, making developers’ work easier. One of Apigee’s best features is its flexibility—it can manage both external APIs for third-party access and internal APIs for company use, making it suitable for companies of all sizes. Apigee also works well with security layers like Nginx, which adds a layer of authentication between Apigee and backend systems. This flexibility and security make Apigee a reliable and easy-to-use platform for managing APIs.

What is Gemini AI?

Gemini AI is an advanced artificial intelligence tool that enhances the management and functionality of APIs. Think of it as a smart assistant that helps automate tasks, answer questions, and improve security for API systems like Apigee. For example, if a developer needs help setting up an API, Gemini AI can guide them with instructions, formats, and even create new APIs based on simple language input. It can also answer common user questions or handle customer inquiries automatically, making the whole process faster and more efficient. Essentially, Gemini AI brings intelligence and automation to API management, helping businesses run their systems smoothly and securely.

Why Should Consumers Opt for Gemini AI with Apigee?

Consumers should choose Gemini AI with Apigee because it offers more innovative, faster, and more secure API management. It also brings security, efficiency, and ease of use to API management, making it a valuable choice for businesses that want to streamline their operations and ensure their APIs are fast, reliable, and secure. Here are some key benefits: Enhanced Security, Faster Development, and Time-Saving Automation.

Below is the flow diagram for Prospective Developments in APIGEE.

Greater Emphasis on API Security

• Zero Trust Security:  The Zero Trust security approach is founded on “never trust, always verify,” which states that no device or user should ever be presumed trustworthy, whether connected to the network or not. Each request for resource access under this architecture must undergo thorough verification.
• Zero Trust Models: APIs will increasingly adopt zero-trust security principles, ensuring no entity is trusted by default. The future of Zero-Trust in Apigee will likely focus on increasing the security and flexibility of API management through tighter integration with identity management, real-time monitoring, and advanced threat protection technologies.
• Enhanced Data Encryption: Future developments might include more substantial data encryption capabilities, both in transit and at rest, to protect sensitive information in compliance with Zero Trust principles.
  
  

Resiliency and Fault Tolerance

 The future of resiliency and fault tolerance in Apigee will likely involve advancements and innovations driven by evolving technological trends and user needs. Here are some key areas where we can expect Apigee to enhance its resiliency and fault tolerance capabilities.

• Automated Failover: Future iterations of Apigee will likely have improved automated failover features, guaranteeing that traffic is redirected as quickly as possible in case of delays or outages. More advanced failure detection and failover methods could be a part of this.
• Adaptive Traffic Routing: Future updates could include more dynamic and intelligent traffic management features. This might involve adaptive routing based on real-time performance metrics, enabling more responsive adjustments to traffic patterns and load distribution.
• Flexible API Gateway Configurations: Future enhancements could provide more flexibility in configuring API gateways to better handle different fault scenarios. This includes custom policies for fault tolerance, enhanced error handling, and more configurable redundancy options.

Gemini AI with Apigee

Gemini AI and Apigee’s integration has the potential to improve significantly API administration by enhancing its intelligence, security, and usability. Organizations can anticipate improved security, more effective operations, and better overall user and developer experience by utilizing cutting-edge AI technologies. This integration may open the door to future breakthroughs and capabilities as AI and API management technologies develop. If the API specifications that are currently available in API Hub do not satisfy your needs, you can utilize Gemini to create a new one by just stating your needs in basic English. Considerable time is saved in the cycles of development and assessment.

Gemini AI can inform you about the policy documentation in parallel while adding policies to the Apigee development. Gemini AI can guide you with the formats used in the policies. We can automate the query region like chatbots with Gemini AI. We may utilize Gemini AI to improve and get answers to questions about the APIs available on the Apigee portal.

If any integration is currently in use. We can use Gemini AI to accept inquiries from customers or clients and automate the most frequently asked responses. Additionally, Gemini AI can simply reply to customers until our professionals are active.

Overview

Apigee, Google Cloud’s API management platform, plays a key role in digital transformation by securely and flexibly connecting businesses with data and services. Future advancements focus on stronger security with a “Zero Trust” approach, improved resilience through automated failover and adaptive traffic routing, and enhanced flexibility in API gateway settings. Integration with Gemini AI will make Apigee smarter, enabling automated support, policy guidance, API creation, streamlining development, and improving customer service.

Hello Trailblazers!

Salesforce Reports are a cornerstone of effective data-driven decision-making. They allow you to analyze and visualize business data efficiently. Salesforce offers a subscription feature for reports to ensure you or your team stay updated on important metrics without manually checking them. Subscribing ensures that you receive reports regularly in your email inbox, making it easy to monitor performance and trends.

In this blog, we’ll learn a step-by-step guide to subscribing to Salesforce Reports.

So stay tuned!

Before You Begin:

In the earlier sections of this Salesforce Reports series, we explored What Salesforce Reports are and the various types of Salesforce Reports. I highly recommend revisiting those sections to gain a deeper understanding and maximize your knowledge.

Why Subscribe to Salesforce Reports?

Subscribing to Salesforce Reports provides numerous benefits, including:

1. Timely Updates: Receive reports at a frequency that suits your business needs.
2. Automation: Eliminate the need to manually run reports.
3. Collaboration: Share critical data with stakeholders without additional effort.
4. Customization: Tailor subscription settings to fit your specific reporting requirements.

Prerequisites for Report Subscription

Before subscribing to reports in Salesforce, ensure the following:

1. Permission to Subscribe: So verify that your profile or role includes the permission to subscribe to reports. If not, contact your Salesforce Administrator.
2. Access to Report: So you must have view access to the report you wish to subscribe to.
3. Email Configuration: Ensure your organization’s email settings in Salesforce are correctly configured for outbound emails.

By the end of this blog, I will have shared some images and demonstrated how you can receive automated email updates for Salesforce Reports by subscribing to them. So keep reading for all the details!

Steps to Subscribe to a Salesforce Report

Step 1: Navigate to the Reports Tab

1. Go to the Reports tab in your Org.
2. Locate the report you want to subscribe.

Step 2: Open the Desired Report

1. Click on the report name to open it.
2. So, review the report to ensure it contains the data you need.

Step 3: Click on the Subscribe Button

1. Once you open the report, click the down arrow menu button beside the ‘Edit’ button in the top right corner.
2. When clicked, a menu will appear.
3. So click the Subscribe button to initiate the subscription process, as shown below.

Step 4: Configure Subscription Settings

1. Set Frequency: Choose how often you want to receive the report. So options include:

1. • Daily
   • Weekly
   • Monthly

2. Select Time: Here, specify when the report email should be sent.

3. Add Conditions (Optional):

• • Define conditions for sending the report.
  • For example, “Send only if revenue is less than $10,000.”

Step 5: Add Recipients

1. Include Yourself: By default, you will be subscribed to the report.
2. Add Others: Add additional users, roles, or groups who should receive the report and ensure they have access to it.

Note: If you would like to learn more about how to give access of the reports to the users, then please follow the provided link.

Step 6: Save the Subscription

1. Review the settings to ensure accuracy.
2. Click Save to activate the subscription.

Your subscription will be visible in the “Subscribed” column, as shown below.

So, you can subscribe to Salesforce Reports.

Note: To learn how to subscribe to Salesforce Dashboards, please explore the detailed blog post by clicking on the provided link.

Managing Report Subscriptions

1. View Current Subscriptions

   • Navigate to the Reports tab and open the report.
   • Click on Subscribe to view and manage your existing subscription settings.

2. Edit Subscriptions

   • Modify the frequency, time, or recipients as required.
   • Save changes to update the subscription.

3. Unsubscribe from Reports

   • If you no longer wish to receive updates, click Unsubscribe from the subscription settings below.

Best Practices for Report Subscriptions:

1. Optimize Frequency: Avoid overloading your inbox by choosing a frequency that matches your reporting needs.
2. Choose Relevant Recipients: Ensure only stakeholders who need the report are included in the subscription.
3. Define Conditions: Use filters to trigger report emails only when specific criteria are met.
4. Test Email Delivery: Confirm that reports are delivered correctly to all recipients.

Result – How do you Receive Emails for Salesforce Reports?

So here, I demonstrate the outcome of receiving Salesforce Dashboard updates via email after subscribing to them.

Click to view slideshow.

Troubleshooting Report Subscription Issues

1. Emails Not Received

   • Check your spam folder.
   • Verify that your email address is correctly entered in Salesforce.
   • Ensure your organization’s email server is not blocking Salesforce emails.

2. Permission Errors

   • Contact your Salesforce Administrator to ensure you have the required permissions.

3. Access Issues

   • Confirm that all recipients have access to the report and its underlying data.

Conclusion

Subscribing to Salesforce Reports is an efficient way to stay informed about your business’s performance metrics. So, by automating the delivery of reports, you save time and ensure timely decision-making. So follow the steps in this guide to set up report subscriptions and optimize your reporting workflow.

Happy Reading!

“Positivity is not about ignoring challenges; it’s about facing them with hope, resilience, and the belief that every setback is a step toward something better.”

Related Posts:

• Schedule and Subscribe to Reports
• Subscribe to Get Report Results Delivered by Email

You Can Also Read:

• Introduction to the Salesforce Queues – Part 1
• Mastering Salesforce Queues: A Step-by-Step Guide – Part 2
• How to Assign Records to Salesforce Queue: A Complete Guide
• An Introduction to Salesforce CPQ
• Revolutionizing Customer Engagement: The Salesforce Einstein Chatbot

Content moderation is a key component of online communities, ensuring the platform remains safe, respectful, and professional for all users. While enforcing rules is essential, content moderation is more than just applying penalties or removing harmful posts. It’s about creating an environment that promotes positive interaction, cooperation, and trust among community members. This is especially vital in a Salesforce Experience Cloud environment, where many users collaborate, share ideas, and engage in discussions. Effective content moderation helps maintain the platform’s integrity, safety, and tone, making it an essential tool for fostering a thriving, positive community.

Managing a large and diverse user base can be challenging. With numerous individuals sharing content, ensuring that all posts align with community values and uphold a professional standard can often be challenging. Without a robust content moderation system in place, harmful or disruptive content—such as spam, offensive language, hate speech, or misinformation—may slip through the cracks and negatively impact the overall experience. Therefore, implementing clear and effective content moderation practices is not just essential but a critical component of maintaining the credibility and success of your community.

Salesforce Experience Cloud provides various powerful moderation tools to assist community administrators in managing user-generated content (UGC). These tools are intended for both automated and manual moderation processes, allowing admins to quickly identify and address inappropriate content while still considering the context through human oversight. This balanced approach ensures a clean and safe environment for all users.

Creating Content Moderation Rules in Salesforce Experience Cloud

One of the most important features of Salesforce Experience Cloud is the ability to set up customizable content moderation rules. These rules can be tailored to fit your community’s specific needs, helping you prevent harmful content from spreading while ensuring that your platform remains a welcoming place for everyone.

Defining Keywords and Phrases

A fundamental aspect of content moderation is identifying words or phrases that may indicate harmful or inappropriate content. Salesforce allows administrators to set up keyword-based rules that automatically flag content containing specific words or phrases. This is especially useful for maintaining a professional and safe space within the community.

For example, in a business-focused community, you may want to flag posts that contain discriminatory language, hate speech, or inappropriate references to politics or religion. The keyword rules in Salesforce are highly customizable, allowing admins to set the tone and standards of the community. These keywords can be fine-tuned based on the community’s goals, ensuring that content aligns with the values you want to promote. Additionally, administrators can adjust sensitivity levels depending on the community type—public forums may have stricter rules, while private groups might allow for more flexibility.

Image Moderation

Image moderation is another essential feature in keeping the community safe and respectful. With the growing popularity of sharing photos and videos online, it is crucial to ensure that multimedia content follows the same guidelines as text-based content. Salesforce Experience Cloud uses AI tools to scan images for inappropriate content, such as explicit material, hate symbols, or violence.

AI-based image recognition is especially valuable in detecting harmful visual content that text filters may miss. For example, a post might include a seemingly harmless caption but feature an offensive or inappropriate image. With AI tools, Salesforce helps catch these violations before they are visible to other users, protecting the platform’s integrity. This feature is handy for communities heavily relying on photo-sharing or visual media, such as art communities or photography-based networks.

User Reports

While automated moderation tools are practical, they are not perfect. Users may encounter content that violates community guidelines but isn’t flagged by the system. To address this, Salesforce Experience Cloud allows community members to directly report inappropriate or harmful content. This enables users to play an active role in maintaining the community’s standards.

When a user submits a report, it is sent to the admin team or moderators for further review. This approach balances automation and human oversight, allowing administrators to assess the content in context before making decisions. The ability to report content helps keep the platform more responsive and adaptable to emerging issues.

Escalation and Manual Review

Sometimes, automated tools may flag borderline or unclear content, and context is needed to make an informed decision. In these situations, Salesforce provides an escalation process. If content is flagged by the system but the admin team is unsure whether it violates community guidelines, it can be escalated for manual review.

Community managers or moderators can assess the content’s context, make a judgment call, and determine whether it should be removed, edited, or allowed to stay. This manual review ensures that moderation is accurate and nuanced, preventing hasty decisions based on incomplete information.

Managing User Visibility in Salesforce Communities

User visibility is another critical aspect of community management. Salesforce Experience Cloud offers various tools to control how user profiles, posts, and other content are displayed to different users based on their membership level or role within the community. By setting appropriate visibility settings, admins can protect sensitive information while creating a more personalized and secure experience for community members.

Key Aspects of User Visibility

1. Role-Based Visibility: Admins can define specific user roles, such as admin, member, or guest, and set visibility permissions based on these roles. For example, only admins can access internal discussions or restricted resources, while members or guests can only view public-facing content. This ensures that users see only the content relevant to their level of participation.
2. Audience-Specific Content: Salesforce also allows admins to make sure content is visible to specific user groups based on their interests or participation in the community. For example, a discussion about advanced programming techniques might only be visible to users with certain expertise, ensuring they are exposed to content relevant to their interests.
3. Privacy Settings: Salesforce Experience Cloud offers robust privacy controls, allowing users to decide who can view their profiles, posts, and personal data. This level of control enhances security, making users feel more comfortable sharing information and engaging with the community. It also helps maintain a positive, respectful atmosphere within the community.

Implementing Rate Limit Rules for Better Control

Rate limits are a powerful tool for controlling the flow of content and user activity within the community. By limiting the number of posts, comments, or interactions a user can make within a specific timeframe, admins can prevent spamming and excessive activity that could overwhelm the platform.

Setting rate limits ensures that content remains high-quality and relevant without flooding the platform with unnecessary or disruptive posts. This is particularly important for larger communities, where the risk of spam or malicious behavior is higher.

Key Benefits of Rate Limit Rules

1. Prevents Spam: Rate limits can prevent users or bots from flooding the community with spammy content by ensuring that posts and interactions are spaced out over time.
2. Protects Community Members: By limiting excessive interaction, rate limits help prevent aggressive behavior or bombardment of users with irrelevant posts, protecting the overall user experience.
3. Optimizes Platform Performance: High activity volumes can strain the platform’s performance, causing lags or disruptions. Rate limits help maintain stability, ensuring that the platform functions smoothly as the community grows.

How to Set Rate Limits

1. Define Thresholds: Set clear limits on how many posts or interactions a user can make in a given time period (e.g., no more than 10 posts per hour). This will help prevent excessive activity and ensure that content remains meaningful.
2. Apply Limits Based on User Behavior: New users or guests might be subject to stricter rate limits, while long-term members can be given more flexibility. This helps prevent spam without discouraging genuine participation.
3. Monitor and Adjust: Regularly assess the effectiveness of your rate limits. Adjust the thresholds to strike the right balance between preventing spam and encouraging engagement if necessary.

Also, visit the articles below:

Salesforce Documentation: Experience Cloud

Optimizing Mobile Experiences with Experience Cloud

Ensuring clear focus visibility is key for accessibility; sometimes, visually impaired users and keyboard navigators have trouble interacting with web content. This blog explores practical ways to fix focus visibility issues and improve user experience.

ADA Compliance Overview

ADA compliance ensures websites are accessible to people with disabilities, promoting inclusivity and fairness. By following the WCAG 2.0 guidelines and the POUR principles (Perceivable, Operable, Understandable, Robust), websites can be made accessible. This helps businesses avoid legal issues enhances user experience, increases engagement, and drives actions like purchases. Additionally, ADA-compliant websites improve SEO, making them crucial for building successful, user-friendly websites.

1. Perceivable

Make content accessible to all senses (text, images, videos) with alternatives like captions, transcripts, or descriptions for those who can’t see or hear. Use attributes like aria-label, alt, and track.

Example

2. Operable

Ensure easy navigation and interaction with content via keyboard, timing controls, focus management, and a clear structure (titles, headings, labels).

Example

The shared navigable nav code in the above HTML focuses on nav list items when the Tab key is pressed.

3. Understandable

For better usability, use clear language, label links to form fields, and maintain consistent navigation with semantic HTML, headings, and lists. Provide a code screenshot for clarity.

Example

4. Robust

Ensure your site works well with assistive technologies so all users get the same content, whether they read it or use a screen reader (NVDA).

Keyboard Focus-Related Issues & solutions

Why Keyboard Focus Matters

ADA compliance ensures that websites are accessible to all users, including those who rely on keyboard navigation or screen readers. One common issue that affects accessibility is the visibility of focus indicators (outlines or borders) when users navigate through interactive elements like links, buttons, dropdowns, and range controls.

The Problem

CSS styles that obscure focus rings can make it difficult for keyboard-only users to identify the focused element. This issue often arises in browsers like Chrome, Firefox, and Internet Explorer, leading to confusion and navigation difficulties.

The Goal

Ensure the focus indicator on interactive elements (e.g., links, buttons, and dropdowns) is clear and visible and meets accessibility guidelines for contrast and size.

Why It’s Crucial

A visible focus indicator is necessary for users who cannot use a mouse, helping them navigate a website efficiently. Sufficient contrast also makes the focus ring visible for users with visual impairments, ensuring inclusivity for all.

Solutions to Overcome Outline Issues

Browsers automatically provide focus indicators for interactive elements, but many developers remove them using the :focus { outline: none; } CSS rule. This is not recommended unless you replace it with a custom focus style. The default focus indicators can clash with the color scheme and become hard to see. To improve accessibility, focus indicators should meet three criteria: color contrast, surface area (size), and visibility.

Focus Indicators are visual markers that show which element is focused, which is especially useful for keyboard navigation. The :focus-visible pseudo-class can apply focus styles only when the keyboard is used.

Ensure the focus ring has:

• At least 2px thickness around the element.
• A contrast ratio of 3:1 between focused and unfocused states.

Use tools like the Color Contrast Checker to verify color contrast.

Solution 1

Add a thicker outline around the button on the keyboard focus, changing the color from white to black. This is called the focus indication area, where the focus indicator and the contrasting area are the same. The contrast ratio here is 21:1, which exceeds the required 3:1, meeting the standard criteria for focus visibility.

*:focus-visible {
    outline: 2px solid #000;
}

Solution 2

When the button receives keyboard focus, add a black outline separated from it. This creates a contrasting area, making the focus indicator stand out more. Use the outline-offset property to add space around the element.

*:focus-visible {
   outline: 2px solid #000;
   outline-offset: 2px;
}

Solution 3

If the button changes its background color from blue to black when it is focused, the entire background area becomes a contrasting area. The color contrast ratio between the focused and unfocused states is 4.68.

You can choose any of these solutions based on your project’s focus indication requirements. Either test it with a screen reader or a recommended accessibility tool.

Note: The outline thickness can be adjusted beyond 2px as long as it meets the focus indication criteria.

Recommended Tools for Accessibility Testing

• Automated Tools: Lighthouse (Chrome DevTools), WAVE, Axe.
• Screen Readers: NVDA, JAWS, or VoiceOver.
• Color Contrast Checkers: WebAIM Contrast Checker.
• Keyboard Testing: Navigate your site using only the keyboard
  • For more details, check Keyboard Accessibility Testing

Many developers use tools like Lighthouse (Chrome DevTools), WAVE, and Axe for accessibility testing. A new tool on the market for accessibility testing is the PowerMapper Tool.

You can learn more about PowerMapper below:

PowerMapper Accessibility Tool

PowerMapper is an accessibility testing tool that checks for broken links, spelling errors, browser compatibility, SEO issues, web standards, and WCAG compliance. Accessibility and usability issues significantly impact user experience, while SEO problems can harm a business’s customer base and make it appear unprofessional.

PowerMapper is a paid tool, and some organizations use it to comply with the Americans with Disabilities Act (ADA). The ADA is a civil law that ensures inclusivity for all individuals, particularly those with disabilities, in public life.

The tool offers a 30-day free trial, a downloadable version, and a web-based option for scanning websites and pages for accessibility testing.

How to Scan a Page Using the PowerMapper Trial

1. Enter the following link in your browser’s address bar: https://www.powermapper.com/products/sortsite/try/
2. A window will open, similar to the one shown below
3. In the “Try Online” input box, enter the URL of the page you want to scan, then click the ‘Scan Website’ button
4. After a few seconds of scanning, a report of issues will be displayed, similar to the screenshot below
5. After clicking on a specific issue, it highlights the relevant HTML code and provides a reference link to resolve the issue
6. The screenshot below shows a focus visibility issue.
7. This way, you can check for focus visibility issues on your website. If any are found, fix them using the above focus visibility solutions and rescan the site.

Conclusion

By improving focus visibility, maintaining a logical focus order, and testing with assistive tools, developers create a more inclusive and user-friendly experience. Accessibility benefits everyone, making the web a better place for all users.

What steps have you taken to improve focus visibility accessibility on your websites? Share your thoughts in the comments below!

In this blog post, I will guide you through the process of implementing a Spring Expression Language (SpEL) validator in a Spring Boot application. SpEL is a powerful expression language that supports querying and manipulating an object graph at runtime. By the end of this tutorial, you will have a working example of using SpEL for validation in your Spring Boot application.

Project Structure

Step 1: Set Up Your Spring Boot Project

First things first, let’s set up your Spring Boot project. Head over to Spring Initializer and create a new project with the following dependencies:

• Spring Boot Starter Web
• Thymeleaf (for the form interface)

  <dependencies>
  	<dependency>
  		<groupId>org.springframework.boot</groupId>
  		<artifactId>spring-boot-starter-web</artifactId>
  		<version>3.4.2</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework.boot</groupId>
  		<artifactId>spring-boot-starter-thymeleaf</artifactId>
  		<version>3.4.2</version>
  	</dependency>
  </dependencies>
  

Step 2: Create the Main Application Class

Next, we will create the main application class to bootstrap our Spring Boot application.

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Step 3: Create a Model Class

Create a SpelExpression class to hold the user input.

package com.example.demo.model;

public class SpelExpression {
    private String expression;

    // Getters and Setters
    public String getExpression() {
        return expression;
    }

    public void setExpression(String expression) {
        this.expression = expression;
    }
}

Step 4: Create a Controller

Create a controller to handle user input and validate the SpEL expression.

package com.example.demo.controller;

import com.example.demo.model.SpelExpression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.SpelParseException;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class SpelController {

    private final ExpressionParser parser = new SpelExpressionParser();

    @GetMapping("/spelForm")
    public String showForm(Model model) {
        model.addAttribute("spelExpression", new SpelExpression());
        return "spelForm";
    }

    @PostMapping("/validateSpel")
    public String validateSpel(@ModelAttribute SpelExpression spelExpression, Model model) {
        try {
            parser.parseExpression(spelExpression.getExpression());
            model.addAttribute("message", "The expression is valid.");
        } catch (SpelParseException e) {
            model.addAttribute("message", "Invalid expression: " + e.getMessage());
        }
        return "result";
    }
}

Step 5: Create Thymeleaf Templates

Create Thymeleaf templates for the form and the result page.

spelForm.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>SpEL Form</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            color: #333;
            margin: 0;
            padding: 0;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
        }
        .container {
            background-color: #fff;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
            text-align: center;
        }
        h1 {
            color: #4CAF50;
        }
        form {
            margin-top: 20px;
        }
        label {
            display: block;
            margin-bottom: 8px;
            font-weight: bold;
        }
        input[type="text"] {
            width: 100%;
            padding: 8px;
            margin-bottom: 20px;
            border: 1px solid #ccc;
            border-radius: 4px;
        }
        button {
            padding: 10px 20px;
            background-color: #4CAF50;
            color: #fff;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        button:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>SpEL Expression Validator</h1>
        <form th:action="@{/validateSpel}" th:object="${spelExpression}" method="post">
            <div>
                <label>Expression:</label>
                <input type="text" th:field="*{expression}" />
            </div>
            <div>
                <button type="submit">Validate</button>
            </div>
        </form>
    </div>
</body>
</html>

result.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Validation Result</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            color: #333;
            margin: 0;
            padding: 0;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
        }
        .container {
            background-color: #fff;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
            text-align: center;
        }
        h1 {
            color: #4CAF50;
        }
        p {
            font-size: 18px;
        }
        a {
            display: inline-block;
            margin-top: 20px;
            padding: 10px 20px;
            background-color: #4CAF50;
            color: #fff;
            text-decoration: none;
            border-radius: 4px;
        }
        a:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Validation Result</h1>
        <p th:text="${message}"></p>
        <a href="/spelForm">Back to Form</a>
    </div>
</body>
</html>

Step 6: Run the Application

Now, it’s time to run your Spring Boot application. To test the SpEL validator, navigate to http://localhost:8080/spelForm in your browser.

For Valid Expression

For Invalid Expression

Conclusion

Following this guide, you successfully implemented a SpEL validator in your Spring Boot application. This powerful feature enhances your application’s flexibility and robustness. Keep exploring SpEL for more dynamic and sophisticated solutions. Happy coding!