Automation is transforming the way businesses operate, streamline workflows, and drive productivity. As organizations continue to adopt modern technologies, the need to harness the power of automation has never been more critical. At TechCon365 PWRCON, Microsoft MVP Amarender Peddamalku is offering two back-to-back hands-on workshops to help attendees master the art of automation with Microsoft Power Automate.

Session 1: Power Automate Bootcamp – From Basics to Brilliance | June 23 | 9:00 am – 5:00 pm

Are you new to automation? Do you want to start your journey with Power Automate? This Power Automate Bootcamp is designed specifically for beginners, offering a deep dive into the core concepts of Power Automate. This session will provide you with the skills and knowledge to confidently build and manage automated workflows, making you an automation pro in no time.

Key Highlights:

• Introduction to Power Automate: Gain a solid understanding of what Power Automate is and how it can simplify your workflows.
• Creating Your First Flow: Step-by-step guidance on building your first automated workflow, utilizing templates to quickly get started.
• Working with Connectors: Learn how to connect Power Automate to various data sources and services, including SharePoint, Teams, and Outlook.
• Building Advanced Flows: Go beyond the basics with conditions, loops, and variables, and integrate your flows with other Microsoft services.
• Error Handling and Troubleshooting: Learn how to monitor and troubleshoot flows, ensuring smooth operations.
• Best Practices and Governance: Understand best practices for building efficient and maintainable flows, and get to grips with governance and security considerations.

This session will include hands-on labs and exercises where you’ll have the chance to create and refine your own flows in real-world scenarios.

Session 2: Power Automate Multi-Stage Approval Workflows | June 24 | 9:00 am – 5:00 pm

Are you looking to design complex approval workflows that meet your organization’s unique needs? This Multi-Stage Approval Workflows workshop is perfect for users who are ready to take their automation skills to the next level. In this session, Amarender will guide you through the intricacies of building robust, multi-step approval workflows that include dynamic approvers, escalations, and advanced features.

Key Highlights:

• Designing Multi-Stage Workflows: Learn how to build workflows that move back and forth between stages, incorporating dynamic approvers and flexible stages.
• Escalations and Reminders: Understand how to automate escalations, reminders, and timeout features to keep workflows on track and ensure timely approvals.
• Advanced Workflow Features: Implement automated reminders, design workflows that can restart from any given stage, and log workflow history beyond the standard Power Automate functionality.
• Integration with SharePoint: Learn how to trigger workflows from SharePoint libraries/lists and optimize workflows to meet your specific business needs.

This session is an excellent opportunity to take your approval workflows to the next level, automating complex approval scenarios that drive efficiency and compliance across your organization.

Why Attend?

Both of these hands-on workshops offer an incredible opportunity to deepen your understanding of automation and learn directly from an industry expert. Whether you’re a beginner or looking to enhance your existing automation skills, Amarender’s workshops are tailored to help you succeed. By the end of these sessions, you’ll be empowered to build powerful, automated workflows that drive business transformation.

Reserve Your Seat Today!

Don’t miss out on these exciting sessions at TechCon365 PWRCON. Seats are limited, so make sure to reserve yours today!

Tickets

Want more? In addition to the workshops, Amarender is also presenting several shorter sessions throughout the week, covering topics like Power Pages, SharePoint Premium, and a condensed version of the Multi-Stage Approval Workflows. Stay tuned for a separate post highlighting these insightful talks!

Continuing our Plop.js journey from the last blog. Be sure to go back and read the previous installment in this series.

In our previous discussion, we explored an introduction to Plop.js and its installation in a Next.js project. Additionally, we looked at a basic skeleton of plopfile.js.

Understanding the Components of plopfile.js

As we saw earlier, the plopfile.js consists of key elements that define the generation. Let’s break them down again for clarity:

• The “setGenerator” creates a plop generator. Here, plopfile.js has a single generator called “basics.”
• The “description,” as the name suggests, describes the purpose of the generator.
• The “prompts” is an array of prompts. This could be added to your created generator.
• The “actions” take the user’s information to each prompt. It is an array of where each action is an object. This is an important step and requires creating some templates.

Creating Our First Template

Before creating a template, understand the concept of actions inside “setGenerator.” After all, this is where the real magic happens. Let’s write a generator to create a new component.

plop.setGenerator("component", {
  description: "Create a new React component",
  prompts: [
    {
      type: "input",
      name: "name",
      message: "What is this component’s name?",
    },
  ],
  actions: [
    {
      type: "add",
      path: "src/components/{{pascalCase name}}/{{pascalCase name}}.tsx",
      templateFile: "plop-template/component.hbs",
    },
  ],
});

Breaking Down the Code

• In the above example, we use the “add” action type, which creates a file at the specified “path” and fills it with a skeleton defined in “templateFile.”
• Plop relies on Handlebars (Handlebars.js), a templating engine for generating structured text like HTML or JavaScript files.
• Notice that the “templateFile” ends with a .hbs extension, which signifies a Handlebars template.

Exploring More Actions

Apart from “add”, there are several other built-in actions like:

• “addMany”
• “modify”
• “append”
• “custom” (for fully customized actions)

You can explore the complete list here: Plop.js Built-in Actions.

Organizing Templates in a Folder

Now that we understand actions, let’s organize our template files.

1. First, create a new folder called plop-template at the root of your project.
2. Inside this folder, create different Handlebar templates for various file types, such as:
   • .tsx for React components
   • .scss for styles
   • .md for documentation
   • .test.tsx for test cases

Handlebars Syntax Example

In Handlebars, variables are enclosed within double curly braces {{}}. Moreover, built-in helpers like “pascalCase” allow the formatting of variables.

const {{pascalCase name}} = () => {
  return <div>{{pascalCase name}} Component</div>;
};

export default {{pascalCase name}};

In addition to “pascalCase,” you can also use:

• “camelCase”
• “snakeCase”
• “lowerCase”

Check out the complete list here: Plop.js Built-in Helpers.

Running the Generator Using Plop

After setting everything up, we are now ready to run our generator! There are two ways to do this:

1. Using CLI Command

2. Using VS Code Script Runner

Alternatively, you can open the package.json file, hover over “generate script,” and click “Run Script” in your editor.

Generating Our First Component with Plop

Next, let’s create our first real component, “Button,” using the plop command npm run generate (with either of the two options mentioned above). After you run the command, the terminal will show prompts as mentioned in the plopfile.js

This will prompt you with questions as per plopfile.js, such as:

1. What is this component’s name? → Button
2. HTML element (default is div)? → button

Once you provide the inputs (refer to the above screenshot to understand better), the component gets created at the specified location, and you will see a success message in the terminal.

Final Thoughts

As you can see, Plop.js simplifies component creation by automating file generation and reducing repetitive tasks. By setting up structured templates, we ensure consistency and boost productivity across the project.

In the upcoming blog, we will explore:

• Other key Plop.js methods (beyond “setGenerator”)
• Built-in and custom actions
• More practical examples

So, stay tuned!

We may all have encountered this situation countless times in our projects—copying and pasting files just to create a new component, page, or service. Unfortunately, this slows us down and hampers our productivity by introducing errors into the workflow. However, there’s a solution! Plop.js is the answer to this problem, as it automates these tasks and allows us to focus on writing great code.

What is Plop.js?

Plop.js is a simple yet powerful scaffolding tool—in other words, a micro-generator framework—that helps us automate repetitive coding tasks for projects. It saves time, reduces errors, and standardizes code structures. Moreover, it ensures uniformity across files, making life easier for the entire team.

Highlight Features

• First and foremost, Plop.js is a template-based file generator.
• Additionally, it is an interactive CLI, enabling a smoother user experience.
• Lastly, you can achieve extensibility through custom actions.

Installation of Plop.js

Plop.js can be installed in any of your projects. To illustrate this, let’s take an example of a Next.js project.

Step 1: Create a Next.js Project

To begin with, create a Next.js project using the following command:

As a result, the above CLI command will prompt you with further questions for setting up your Next.js project.
(Select answers as per your requirement):

• What is your project named? my-app
• Would you like to use TypeScript? No / Yes
• Would you like to use ESLint? No / Yes
• Would you like to use Tailwind CSS? No / Yes
• Would you like your code inside a ‘src/’=’ directory? No / Yes
• Would you like to use App Router? (recommended) No / Yes
• Would you like to use Turbopack for ‘next dev’? No / Yes
• Would you like to customize the import alias (‘@/*’ by default)? No / Yes

Step 2: Install Plop.js

Once your Next.js project is set up, navigate to the project folder and install Plop.js using the command below:

This Installation Generates 3 Key Files

1. A node_modules folder for all your libraries, packages, and third-party code.
2. A package.json file will give you a starting point for your scripts.
3. A package-lock.json file will lock down the versions for each package.
   

In addition to this, installing Plop globally is optional but recommended:

Step 3: Create plopfile.js

Next, create a plopfile.js at the root of your project. Below is a very basic example of plopfile.js

module.exports = function (plop) {
  plop.setGenerator("basics", {
    description: "My first Plop generator",
    prompts: [
      {
        type: "input",
        name: "name",
        message: "What is the name of your component?",
      },
    ],
    actions: [
      {
        type: "add",
        path: "./components/{{pascalCase name}}.js",
        templateFile: "templates/component.hbs",
      },
    ],
  });
};

Breaking Down the Code

• The “setGenerator” creates a plop generator. Here, plopfile.js has a single generator called “basics.”
• The “description,” as the name suggests, describes the purpose of the generator.
• The “prompts” is an array of prompts. This could be added to your created generator.
• The “actions” take the user’s information to each prompt. It is an array of where each action is an object. This is an important step and requires creating some templates.

Step 4: Add a Script to package.json

Before running Plop, add the following script (highlighted in the screenshot below) to package.json.

Step 5: Run plop

Lastly, run plop through the CLI command “npm run generate.”

Now, Plop will execute and guide you through the component creation process!

What’s Next?

So far, we’ve covered the introduction and installation of Plop.js and a basic skeleton for plopfile.js.
In the next part, Plop.js Template Creation, we will explore plopfile.js more thoroughly, replace the skeleton code with working code, and create our first real template. Stay tuned!

As an AEM author, updating existing page content is a routine task. However, manual updates, like rolling out a new template, can become tedious and costly when dealing with thousands of pages.

Fortunately, automation scripts can save the day. Using Groovy scripts within AEM can streamline the content update process, reducing time and costs. In this blog, we’ll outline the key steps and best practices for using Groovy scripts to automate content updates.

The Benefits of Utilizing Groovy Scripts

Groovy is a powerful scripting language that integrates seamlessly with AEM. It allows developers to perform complex operations with minimal code, making it an excellent tool for tasks such as: 

• Automating repetitive tasks

• Accessing and modifying repository content 

• Bulk updating properties across multiple nodes

• Managing template and component mappings efficiently

The Groovy Console for AEM provides an intuitive interface for running scripts, enabling rapid development and testing without redeploying code.   

Important things to know about Groovy Console 

• Security – Due to security concerns, Groovy Console should not be installed in any production environment.  

• Any content that needs to be updated in production environments should be packaged to a lower environment, using Groovy Console to update and validate content. Then you can repackage and deploy to production environments.  

How to Update Templates for Existing Web Pages

To illustrate how to use Groovy, let’s learn how to update templates for existing web pages authored inside AEM. 

Our first step is to identify the following:

• Templates that need to be migrated

• Associated components and their dependencies

• Potential conflicts or deprecated functionalities

You should have source and destination template component mappings and page paths.  

As a pre-requisite for this solution, you will need to have JDK 11, Groovy 3.0.9, and Maven 3.6.3.   

Steps to Create a Template Mapping Script 

1. Create a CSV File 

The CSV file should contain two columns: 

• Source → The legacy template path. 

• Target → The new template path. 

Save this file as template-map.csv.

Source,Target 

"/apps/legacy/templates/page-old","/apps/new/templates/page-new" 

"/apps/legacy/templates/article-old","/apps/new/templates/article-new"v

2. Load the Mapping File in migrate.groovy 

In your migrate.groovy script, insert the following code to load the mapping file: 

def templateMapFile = new File("work${File.separator}config${File.separator}template-map.csv") 

assert templateMapFile.exists() : "Template Mapping File not found!"

3. Implement the Template Mapping Logic 

Next, we create a function to map source templates to target templates by utilizing the CSV file. 

String mapTemplate(sourceTemplateName, templateMapFile) { 

    /*this function uses the sourceTemplateName to look up the template 

    we will use to create new XML*/ 

    def template = '' 

    assert templateMapFile : "Template Mapping File not found!" 

 

    for (templateMap in parseCsv(templateMapFile.getText(ENCODING), separator: SEPARATOR)) { 

        def sourceTemplate = templateMap['Source'] 

        def targetTemplate = templateMap['Target'] 

        if (sourceTemplateName.equals(sourceTemplate)) { 

            template = targetTemplate 

        } 

    }   

        assert template : "Template ${sourceTemplateName} not found!" 

         

    return template 

}

After creating a package using Groovy script on your local machine, you can directly install it through the Package Manager. This package can be installed on both AEM as a Cloud Service (AEMaaCS) and on-premises AEM.

Execute the script in a non-production environment, verify that templates are correctly updated, and review logs for errors or skipped nodes. After running the script, check content pages to ensure they render as expected, validate that new templates are functioning correctly, and test associated components for compatibility. 

Groovy Scripts Minimize Manual Effort and Reduce Errors

Leveraging automation through scripting languages like Groovy can significantly simplify and accelerate AEM migrations. By following a structured approach, you can minimize manual effort, reduce errors, and ensure a smooth transition to the new platform, ultimately improving overall maintainability. 

More AEM Insights

Don’t miss out on more AEM insights and follow our Adobe blog! 

In today’s world, automation and self-service is all around us. From self-order tablets at restaurants to self-checkout lanes at grocery stores and self-check in kiosks at airports, the ability to complete tasks without requiring additional human assistance is incredibly valuable, saving both time and resources.

For organizations utilizing ServiceNow as their IT Service Management (ITSM) platform, the ServiceNow Virtual Agent offers a powerful solution to streamline support and enhance the self-service experience for users.

What is the ServiceNow Virtual Agent?

The ServiceNow Virtual Agent is an intelligent conversational chatbot that provides 24/7 automated support. It enables users to resolve common IT service issues, submit new IT incidents/requests, and find information stored in knowledge bases.

Users can quickly get resolutions without waiting for human assistance. By handling routine inquiries and tasks, the Virtual Agent can reduce the volume of calls and lessen the workload of Service Desk agents, allowing them to focus on more complex issues. In other words, the Virtual Agent can act as a tier 1 level support, deflecting mundane tasks from the Service Desk.

Key features and benefits

Out-of-the-box conversation topics

ServiceNow provides out-of-the-box conversation topics that can quickly be tailored to an organization’s existing processes, resulting in immediate business value, such as:

• Open IT Ticket
• Password Reset
• Unlock Account
• VPN Connectivity
• Hardware Issues

Natural language understanding

The Virtual Agent comes with pre-built natural language understand (NLU) models, allowing the Virtual Agent to understand what the user enters into the chat and map it to specific topics, for example:

• “My account is locked”
• “I cannot connect to the VPN”
• “I need a new keyboard”

Custom NLU models can also be created and trained for terminology specific to the organization.

Topic recommendation analysis

The ServiceNow platform has machine learning capabilities that can analyze historical Incident data, identifying frequent issues within the organization and then recommend new topics for the Virtual Agent.

Multi-channel integration

The ServiceNow Virtual Agent can easily be integrated across multiple channels, including:

• Employee Center/Service Portal
• Intranet site
• Microsoft Teams
• Slack
• ServiceNow Now Mobile.

This ensures users can receive automated support easily, anywhere and anytime.

Transfer to live agent

In scenarios where users cannot resolve their issue with the Virtual Agent, a request can be made to reroute the chat to a live Service Desk agent. The agent can view the user’s chat logs with the Virtual Agent and provide further assistance.

Conversational Analytics

In addition to reporting capabilities available within the ServiceNow platform, the Virtual Agent comes with a built-in Conversational Analytics dashboard that provides insight on user interactions. This lets admins see data on how the Virtual Agent is performing, and allows them to optimize it further.

Example use cases

Below are two examples of how the ServiceNow Virtual Agent can provide users self-service options to resolve common issues, reducing the number of calls and repetitive tasks that the Service Desk receives.

Password reset

Without Virtual Agent: a user calls the Service Desk and talks with an agent because they require instructions on how to reset their password.

With the Virtual Agent: a user initiates a new chat, selects the Password Reset topic, and the Virtual Agent will guide them through the self-service password reset process.

Troubleshooting computer issues

Without Virtual Agent: a user calls the Service Desk and describes an issue they are experiencing on their computer. The Service Desk agent spends time trying to diagnose the issue and provide a solution.

With Virtual Agent: a user initiates a new chat and provides details of a computer issue. The Virtual Agent searches the knowledge base and suggests solutions.

Imagine running a business where you offer subscription-based products. As your customer base grows, you begin to notice something slipping—renewal deadlines, contract complexities, and your sales team being bogged down with manual updates. Enter Salesforce CPQ (Configure, Price, Quote), a powerful tool designed to help businesses streamline the often-complex process of managing quotes, pricing, and contracts. But that’s not all—Salesforce CPQ’s renewal and amend functionalities are here to make your contract management process seamless and automatic.

Let’s dive into how CPQ works, how it simplifies renewals and amendments, and why it’s a game-changer for any business using subscription models.

What is Salesforce CPQ?

At its core, Salesforce CPQ helps businesses configure their products, set pricing, and generate quotes quickly and accurately. Whether your product comes in different sizes, packages, or configurations, CPQ automates the process of calculating pricing based on your business rules, ensuring everything stays consistent. It also handles complex contracts, helping your sales team focus on selling rather than getting lost in the weeds of paperwork.

Now, imagine adding automation to this process, especially when it comes to renewing contracts or amending existing ones. This is where CPQ truly shines, offering standard functionality that reduces the workload while improving accuracy and customer satisfaction.

The Challenge of Renewals

Picture this: It’s the start of the week, and your inbox is overflowing with reminders—expiring contracts, upcoming renewals, and customer requests for service changes. Each contract has unique pricing, terms, and configurations. Manually tracking them is time-consuming and prone to human error. Missing a renewal date could lead to a loss of revenue or, worse, a dissatisfied customer.

Managing renewals manually can be overwhelming. But with Salesforce CPQ’s renewal functionality, this process is automated. Contracts are renewed at the right time, with minimal intervention from your team. No more worrying about missed deadlines or scrambling to send out renewal quotes. The system handles it for you, transforming what was once a cumbersome task into a smooth, efficient process.

How Renewal Functionality Works

Let’s say you have a loyal customer, Sara, whose subscription is nearing its end. In the past, you might have had to manually track her contract, reconfigure the terms, and send her a quote. But now, thanks to Salesforce CPQ’s renewal feature, the system automatically generates a renewal quote in advance, accounting for any updated pricing or discounts.

Your sales team receives a notification and can review the quote before sending it out. Sara, impressed with the efficiency, signs off on the renewal without delay. The entire process is handled smoothly, saving your team hours of manual work and ensuring customer satisfaction. Renewals become a way to strengthen your customer relationships, all while keeping your operations running efficiently.

Tackling Contract Amendments with Ease

But what happens when a customer wants to make changes mid-contract? Perhaps Sara reaches out midway through the year, wanting to upgrade her service package. In the past, you’d have to manually adjust the contract, update pricing, and notify the billing team. The whole process was time-consuming and left room for mistakes.

That’s where Salesforce CPQ’s amend functionality comes into play. Instead of starting from scratch, the system pulls up the existing contract, applies the requested changes, and automatically updates the quote. Whether Sara wants to add more users to her service or change the scope of her subscription, the amend functionality ensures everything is handled efficiently.

The amend feature also updates billing automatically, preventing errors that could arise from manual adjustments. Your team saves time, reduces the risk of miscommunication, and ensures that your customer is getting exactly what they need—without the hassle.

Automation Transforms Business Operations

Let’s face it—managing contracts manually is inefficient. Every contract expiration requires revisiting the original terms, configuring renewal details, and generating quotes. The more complex the contract, the higher the chances of errors. Handling amendments mid-term also introduces challenges, often leading to confusion or customer dissatisfaction.

But with Salesforce CPQ’s automated renewal and amend functionalities, the pressure is off. These features allow you to focus on what matters most: growing your business and building relationships with your customers. Automation increases accuracy, reduces manual effort, and ensures no details slip through the cracks.

Conclusion: A New Era of Contract Management

If your business is still managing renewals and amendments manually, now is the time to embrace the future with Salesforce CPQ. By automating these critical processes, you not only save time but also improve customer experience and protect your revenue streams.

Think about Sara—her smooth, seamless contract renewal and service upgrade are just one example of how CPQ’s renewal and amend features make a real difference. Your team can now focus on closing new deals, knowing that contract management is handled automatically.

Say goodbye to manual management and welcome the efficiency of Salesforce CPQ. It’s time to streamline your operations and let automation pave the way to a more successful, customer-focused future.

The energy was electric last week as thousands of attendees invaded MGM Grand along the Las Vegas Strip for the 3rd Annual Power Platform Community Conference (PPCC24).

From groundbreaking announcements to new features unveiled during keynotes from Microsoft’s Charles Lamanna, Corporate Vice President of Business Industry and Copilot, and Jeff Teper, President of Apps and Platforms, PPCC24 offered an electrifying three days of innovation and collaboration.

Lamanna kicked off day one with an eye-opening overview of Microsoft’s low-code superhero of today, Power Platform. With more than 48 million active users every month – surpassing the population of Spain – Power Platform has become the “one platform” for everyone, whether it’s for no code, low code or pro code. But what truly stole the show this year was Copilot – set to revolutionize how developers work, bringing automation dreams to life.

The future of low-code development is evolving, and at PPCC24, it was clear: Power Platform plus Copilot equals transformative potential for businesses across industries, signaling a new road ahead for citizen developers and Microsoft automation:

“Most people overestimate what they can do in one year and underestimate what they can do in ten years.”

Let’s dive into key announcements and takeaways from PPC24:

The Rise of AI and Natural Language in Power Platform

AI is more deeply integrated into Power Platform than ever before, with a major emphasis on natural language capabilities and intelligent apps. Here are some of the top features unveiled during the conference:

• Desktop Flows from Natural Language – Now in public preview, this feature enables users to generate desktop flows in Power Automate simply by using natural language. The barriers to automation just got lower for everyone, regardless of technical expertise.

• Power Automate AI Recording for Desktop Flows – Also in public preview, this “show and tell” experience allows users to record desktop flows, making RPA workflows easier for users of all skill levels. The AI will interpret recordings to generate automated processes, speeding up adoption and productivity.

• AI Agents for Copilot Studio – A game-changer for developers, AI agents will dynamically execute actions based on instructions and automatically handle workflow based on parameters. These agents can be trained and improved continuously, turning Copilot Studio into a true powerhouse for automation.

Coauthoring in Power Apps Now Generally Available

A highly anticipated feature from the Power Community, Co-Authoring in Power will beckon the next level of developer collaboration. This functionality allows up to 10 developers to collaborate in real time, editing apps simultaneously and a bringing new level of teamwork to app development.

As Charles Lamanna put it, “We are now all coauthors of this vision.” The seamless collaboration made possible through coauthoring will undoubtedly push the boundaries of what’s possible for low-code development.

The Road Ahead is Copilot-First

A standout theme from the conference was a Copilot-first vision for the future of low-code development. With tools like Copilot Studio set to be upgraded with GPT-4, the next generation of low-code technologies will be supported by AI agents that assist with tasks like solution design, data modeling, development, and visual design.

Perficient a Standout in Power Platform’s Future

As a leading Microsoft Solutions Partner, ranked 12th for Microsoft Power Platform partners, Perficient is thrilled to be at the forefront of this Community. From hosting a successful happy hour at Chez Bippy’s the night before the conference, to engaging with attendees at our booth—where we proudly supported donations to St. Jude’s Children’s Hospital—we’re excited to continue building on PPCC24 momentum. Our focus on helping organizations harness the full power of the latest Power Platform features to innovate faster and more intelligently will continue to help us lead the way.

While PPCC24 offered new announcements and innovations, it is only the beginning. As an award-winning Microsoft Solutions Provider, we’re committed to building groundbreaking solutions and bringing the robust capabilities of Power Platform to organizations everywhere. Whether it’s through AI-driven automation, real-time app coauthoring, or our continued work with Copilot, we’re dedicated to empowering businesses to innovate at scale.

Read more about our Power Platform practice here and stay tuned for upcoming events, workshops, and other exciting Power Platform activities!

The Power Platform Community Conference 2024 in Las Vegas is fast approaching, and it’s shaping up to be one of the most impactful events of the year for anyone involved in digital transformation. Whether you’re a seasoned professional or just getting started with Microsoft’s Power Platform, this conference offers unparalleled opportunities to learn, connect, and grow. At Perficient, we’re excited to share our expertise, showcase our success stories, and connect with you to explore how we can help you maximize your Power Platform investment. Here’s everything you need to know to make the most of this conference, from what to expect to why you should engage with Perficient.

What is the Power Platform Community Conference?

The Power Platform Community Conference (PPCC) is the premier event for professionals who use or are interested in Microsoft’s Power Platform. This annual gathering brings together thousands of developers, business leaders, and technology enthusiasts from around the world to explore the latest trends, tools, and best practices in Power Platform. PPCC 2024 is set to showcase cutting-edge AI innovations, building on the success of previous years. It offers more than 150 sessions and keynotes, along with 20 hands-on workshops, and opportunities to connect with and gain insights from Microsoft thought leaders, product experts and developers, MVPs, and peers.

Key Takeaways from Last Year’s Conference

The 2nd annual Power Platform Community Conference in 2023 was a major success, highlighting the growing momentum behind low-code development. Some key takeaways include:

• Low-Code Momentum: The 2023 conference underscored the rapid expansion of the low-code market, with Power Platform playing a central role in enabling organizations to innovate quickly and efficiently.
• AI-Powered Solutions: There was a significant focus on integrating AI with Power Platform, particularly through tools like AI Builder and Power Automate. These advancements are helping organizations automate more complex tasks, driving efficiency, and reducing manual work.
• Community and Collaboration: The strength of the Power Platform community was a key theme, with thousands of professionals collaborating to share insights, solutions, and best practices.

What’s New for the 2024 Conference?

The 2024 conference will build on these themes, with an even stronger focus on AI-driven innovation. Microsoft plans to unveil several new AI features designed to help users automate more complex tasks and gain deeper insights from their data. The conference will highlight how generative AI advancements can be integrated seamlessly with existing Power Platform solutions to enhance productivity and efficiency.

This year, you can expect:

• Showcasing AI Innovations: New AI capabilities in Copilot Studio, Power Automate, Power BI, and AI Builder that simplify the implementation of intelligent automation and analytics solutions.
• Hands-On Labs and Networking: Continued opportunities to engage directly with the technology through hands-on labs and to connect with other professionals and experts in the field.
• Expert-Led Sessions: Sessions led by industry experts focused on how AI is transforming the approach to digital transformation.

For more details on what to expect from this year’s conference, check out Microsoft’s announcement here.

Getting Registered

To register for the Power Platform Community Conference, visit the official conference registration page. Full conference passes start at $1,849 and will be raised to $1,899 after August 27^th. You can add on one, two, or three full-day workshops for additional costs.

Once registered, take some time to plan your conference experience by reviewing the agenda and identifying which sessions align with your current projects or areas of interest.

Why Perficient Leads in Power Platform Solutions

At Perficient, our passion for Power Platform stems from its transformative impact across various industries. We’ve developed a proven track record, backed by 30+ certified experts and over 50 successful enterprise projects, delivering tangible results for our clients. Whether it’s implementing a Center of Excellence (COE) for a global auto manufacturer or building an automation program for a healthcare provider, our diverse industry experience allows us to craft tailored solutions that address unique business challenges.

We understand that every organization is at a different stage of its Power Platform journey. Whether you’re just starting or looking to optimize, our solutions and workshops are designed to align with your organization’s maturity level, ensuring you maximize your Power Platform investment.

Why Talk to Us at PPCC24

1. Custom Solutions for Unique Challenges: We tailor our Power Platform solutions to meet your specific business needs, from app development to automation and data analytics.
2. Deep Industry Insights: Our extensive experience across industries equips us with the insights needed to leverage Power Platform for addressing sector-specific challenges.
3. Commitment to Long-Term Success: Beyond implementation, we offer ongoing support, maintenance, and optimization to ensure your Power Platform environment continues to deliver value as your business grows.

By connecting with Perficient at PPCC24, you’re not just getting a solution; you’re gaining a partner committed to your success.

We’re looking forward to the Power Platform Community Conference and hope to see you there. Be sure to visit us at booth #134, where you can learn more about our success stories, discuss your specific challenges, and discover how Perficient can help you harness the full potential of Power Platform. Let’s work together to turn your vision into reality.

For more information about our Power Platform capabilities, visit Perficient’s Power Platform page.

In IBM Sterling OMS, Exception Handling is the procedure for managing deviations from the normal order processing flow – including incorrect pricing, missing information, inventory issues, stock shortages, payment issues, or shipping errors – which require immediate attention to preserve service quality and operational continuity. Retail businesses manage order processing and exception handling through manual entries and semi-automated systems. These tasks are typically divided among customer service teams, logistics staff, and operations managers, who rely heavily on traditional tools like spreadsheets and email communications.

The Strategic Impact of Automation

Order Exception handling procedures are crucial to maintaining competitive advantage and customer satisfaction. This traditional approach affects workload. A report suggests that employees spend around 30% of their time managing email alone, which involves communications related to order and exception management. In addition to being time-consuming, these manual processes are prone to errors that can affect your bottom line and customer satisfaction. With rising consumer expectations for quick service and flawless execution, automating these processes has become a strategic priority. Automation can transform every aspect of exception handling by improving efficiency and precision.

In IBM OMS, we have a reprocessing flag which makes the exception re-processible. And there is not out of the box automation process.

Automatic exception handling can be done in various ways in OMS including the following.

1. Writing a utility: We can write a utility to query all the alerts and exceptions and have all the possible solution for each exception. For example, getting cache issue because of multi thread while creating the order. In this case, simple reprocess will work. So, we need to specify the Error code inside utility to reprocess this exception.

In Utility, we must call the OMS rest API to get the exception and its details and then identify the solution and based on that reprocess as it is or modify the xml and reprocess.

Some time we must modify the input xml to fix the issues and reprocess with modified xml.

• Pros: This is the better automatic exception resolution in SAS environment. We are not allowed to query directly to database.
• For any changes to utility, we do not need a build.
• Cons: we need a separate environment to run this utility.

2. Writing an agent servers: We process the exception within the OMS. In this case we create an agent server in OMS. We will have to specify error codes and what to do for what error, fix the exception and reprocess or just reprocess depending upon the error code.

• Pros: This does not require a separate environment to run this utility, we can create OMS agent server to use this.
• Cons: This will be tied to the project workspace and if we need to change any code, it must be done using the build process.

3. Utility with database query: This can only be done in on-perm, Sas environment does not support the querying database directly. In this case we get directly query the database to get the exceptions and then reprocess or fix and reprocess depending upon specify error codes the exception using API.

• Pros: This is an easy and quick utility where you just write the database query and reprocess.
• Cons: we need a separate environment to run this utility

4. Reprocess when you get the exception – This automatic resolving exception has limitation as if it is not handled properly, it can cause the server to crash or not process the actual message. And since the risk of the implementation is too high, it is highly recommended to minimize this implementation or do it properly so that it never gets stuck in a loop.

• Pros: This does not require any overhead or utility to reprocess the exception.
• Cons: This can only be done for certain exception which we know can be fixed by reprocess

Advantages of Automation

• Operational cost reductions from minimizing manual labor and streamlining processes. Automation can cut operational expenses related to order processing by up to 40% by reducing the need for manual labor and decreasing the incidence of errors.
• Accuracy enhancements and lower error rates in order processing.

• Automated systems are highly scalable, allowing businesses to handle increased order volumes without proportionate staffing or manual workload increases.

Automation significantly improves customer satisfaction and loyalty by ensuring accurate, timely order processing and proactive exception handling. Automation not only brings substantial cost savings and operational efficiencies, but it also enhances the overall customer experience, paving the way for sustained business growth and success. Automation can be a valuable tool in managing order exceptions. By automating the process, we can reduce the risk of human error and ensure that exceptions are handled consistently. These benefits are not just specific to IBM Sterling OMS, but any OMS system can have these benefits by automating the processing of exceptions.

Navigating the complexities of cloud technology requires an exceptional partner. We are thrilled to announce that Perficient has been named a Major Player in the IDC MarketScape: Worldwide Cloud Professional Services 2024 Vendor Assessment (Doc #US51406224, June 2024).

What Does This Inclusion Mean for Perficient?

“We’re honored to be recognized as a Major Player in this IDC MarketScape Report, a distinction we believe highlights our holistic approach to cloud strategy and our implementation expertise,” said Glenn Kline, Perficient’s Area Vice President of Product Development Operations. “We combine our Envision Framework, migration and modernization expertise, and our strong network of partnerships with leading cloud providers to drive measurable business outcomes for our customers. Our Agile-ready global team enables businesses to think big, start small, and act fast so they can scale their cloud ecosystem over time and deliver on the outcomes promised by cloud computing.”

According to the IDC MarketScape, businesses should “consider Perficient if [they] are looking for a midsized cloud services provider that can combine client intimacy with industrial-strength capabilities in technology transformation and experience design and build.” Additionally, our global managed services group has created comprehensive accelerators such as the App Modernization IQ, Cloud FinOps IQ, and Green Impact IQ, serving as effective tools for guiding clients in cloud operations strategies.

What Does This Mean for Our Clients?

We believe this inclusion reaffirms Perficient as a trusted partner in cloud transformation. Perficient Cloud, our comprehensive suite of six solution areas, serves as a roadmap to navigate the evolving landscape of cloud technology. These areas focus on delivering critical business and technology capabilities, with agnostic offers and accelerators tailored to meet the unique needs of each client. Our Agile-ready global team enables businesses to think big, start small, and act fast, allowing scalable cloud ecosystems that maximize investment. Our focus areas include:

• Technology Modernization: Enhancing performance and efficiency through updated infrastructure.
• Product Differentiation: Creating innovative product offerings that stand out.
• Customer Engagement: Improving interactions and experiences with personalized, data-driven approaches.
• Data & AI Enablement: Driving insights and innovation with advanced analytics and AI.
• Automation & Operational Agility: Boosting efficiency with automation solutions.
• Sustainable Practices: Promoting responsible and impactful cloud strategies.

Join Us on Our Cloud Journey

We believe our inclusion in the IDC MarketScape report highlights our commitment to helping businesses navigate the complexities of cloud transformation. We are dedicated to delivering top-tier cloud solutions that drive growth and innovation.

To learn more about Perficient’s cloud professional services, download the IDC MarketScape: Worldwide Cloud Professional Services 2024 Vendor Assessment report available to IDC subscribers and for purchase. You can also read our News Release for more details on this recognition.

Introduction:

Regular expressions, often abbreviated as regex, stand as indispensable assets for automation engineers. These dynamic constructs facilitate pattern matching and text manipulation, forming a robust foundation for tasks ranging from data validation to intricate search and replace operations. This comprehensive guide aims to navigate through the intricacies of regex, catering to various proficiency levels — from beginners to intermediates and advanced users.

Beginner-Friendly Regex

\d – Digit Matching

The \d expression is a foundational tool for identifying digits within the 0-9 range. For instance, using \d{3} allows precise capture of three consecutive digits, offering accuracy in recognizing numerical patterns. In a practical scenario:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "The price is $500.";

        Pattern pattern = Pattern.compile("\\d{3}");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

\w – Embracing Word Characters

\w proves useful for recognizing word characters, encompassing alphanumeric characters and underscores. When coupled with the + quantifier (\w+), it transforms into a versatile tool for capturing one or more word characters. For example:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "User_ID: john_doe_123";

        Pattern pattern = Pattern.compile("\\w+");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

\s – Recognizing Whitespace Characters

\s becomes the preferred expression for identifying whitespace characters, including spaces, tabs, and line breaks. The flexibility of \s* enables the recognition of zero or more whitespace characters. An example:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "   This is a sentence with spaces.   ";

        Pattern pattern = Pattern.compile("\\s*");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

Intermediate Regex Techniques

\D – Non-Digit Character Recognition

Building on the \d foundation, \D complements by identifying any character that is not a digit. The application of \D+ efficiently captures one or more non-digit characters. Consider the following:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "#XYZ123";

        Pattern pattern = Pattern.compile("\\D+");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

\W – Non-Word Character Identification

Parallel to \w, \W expands the horizon by identifying any character that is not a word character. Consider \W{2,} for capturing two or more non-word characters. Example:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "Special characters: @$!%";

        Pattern pattern = Pattern.compile("\\W{2,}");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

Advanced Regex Tactics

[g-s] – Character Range Inclusion

Introducing the concept of character ranges, [g-s] identifies any character falling between ‘g’ and ‘s,’ inclusive. This proves valuable for capturing a specific set of characters within a defined range. For instance:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "The highlighted section goes from g to s.";

        Pattern pattern = Pattern.compile("[g-s]+", Pattern.CASE_INSENSITIVE);

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

Real Data Application

True proficiency in regex lies in its practical application to real-world data. Regularly practicing with authentic datasets enhances understanding and proficiency.

Suppose you have a dataset of phone numbers, and you want to extract all the area codes. You could use the following regex:

import java.util.regex.*;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {

        String data = "Phone numbers: (123) 456-7890, (987) 654-3210, (555) 123-4567";

        Pattern pattern = Pattern.compile("\\(\\d{3}\\)");

        Matcher matcher = pattern.matcher(data);

        List<String> areaCodes = new ArrayList<>();

        while (matcher.find()) {

            areaCodes.add(matcher.group());

        }

        System.out.println("Area Codes: " + areaCodes);

    }

}

Output:

In Conclusion:

In conclusion, regex stands as a powerful tool that, when employed adeptly, empowers automation engineers to tackle diverse challenges in software development and testing. By comprehending the nuances of regex expressions at different proficiency levels, engineers can enhance their ability to create efficient and effective automation scripts.

Seamless integration between various systems and applications is crucial for efficient data sharing and enhanced functionality. Appian, a leading low-code automation platform, recognizes this need and provides a powerful toolset for creating Web APIs.

Web APIs: Bridging the Gap

Web APIs, or Application Programming Interfaces, serve as a bridge between different software applications, enabling them to communicate and share data seamlessly. In the context of Appian, Web APIs provide a way to expose Appian data and services to external systems, facilitating integration with other software solutions.

Key Features of Web APIs

• Integration and Data Exchange: Appian’s Web API feature allows for seamless integration with external systems and services, enabling the exchange of data in real time. It supports RESTful web services, which can be used to expose Appian data and processes to other applications or to consume external data within Appian.
• Security and Customization: Appian Web APIs come with built-in security features such as authentication and authorization, ensuring that only authorized users can access the API. Additionally, they can be customized to perform complex business logic, validate inputs, and format responses, providing flexible and secure data handling capabilities.
• Scalability and Performance: Appian Web APIs are designed to handle high volumes of requests efficiently, ensuring that performance remains optimal even as the demand grows. This scalability is crucial for enterprise-level applications that require reliable and fast data processing and integration capabilities.

How to Harness the Power of Web APIs in Appian

Define Your API

• When defining your API, carefully choose the URLs or URIs that serve as access points for various resources or specific actions within your system. This crucial step sets the foundation for seamless interaction with your API.

Create the API in Appian

1. Choose the Appropriate HTTP Methods
   • Determine the HTTP methods by specifying which ones (GET, POST, PUT, DELETE, etc.) your API will support for each endpoint.
   • Define the request/response formats by specifying the data formats (such as JSON, XML, etc.) that your API will use for sending requests and receiving responses.
2. Design Your API
   • Consider the needs of both Appian and the external system when designing your Web API. Define clear and concise documentation that outlines the API’s functionality, required parameters, and expected responses.
3. Implement Security Measures
   • Security actively takes centre stage when exposing your Appian data and services to external systems. Actively implement authentication and authorization mechanisms, such as API keys or OAuth tokens, to ensure that only authorized entities can actively access your API.

Test Thoroughly

• Before making your Web API available to external systems, thoroughly test it using various scenarios and edge cases. Identify and resolve potential issues to ensure a smooth and reliable integration experience.

Deploy the API

• Once you have finished creating and testing your API, deploy it to the desired environment (development, test, or production).
• Ensure that the necessary resources (servers, databases, etc.) are appropriately configured and accessible for the API to function correctly in the deployment environment.

Document and Publish the API

• Create documentation for your API, including details about the endpoints, supported methods, request/response formats, input/output parameters, and any authentication/authorization requirements.
• Publish the documentation internally or externally to make it available to the API consumers.

Monitor and Maintain

• Establish monitoring and logging mechanisms to track your API’s performance, usage, and errors.

Challenges while developing Appian Web API

• Authentication Challenges: Struggles with configuring and maintaining authentication methods like API keys, tokens, or OAuth can result in issues accessing the system.
• Data Validation Complexity: Verifying and managing data input accuracy, as well as dealing with validation errors, can be tricky, particularly with intricate data structures.
• Endpoint Configuration: Errors in configuring endpoints, including incorrect URLs or URIs, can disrupt API functionality.
• Security Vulnerabilities: Overlooking security best practices may expose APIs to vulnerabilities, potentially leading to data breaches or unauthorized access.
• Third-Party Service Dependencies: If the API relies on third-party services, developers may face difficulties when those services experience downtime or changes.
• Error Handling: Inadequate error handling and unclear error messages can make troubleshooting and debugging challenging.
• Documentation Gaps: Poorly documented APIs or incomplete documentation can lead to misunderstandings, making it difficult for developers to use the API effectively.
• Integration Challenges: Integrating the API with external systems, especially those with differing data formats or protocols, can pose integration challenges.

Developers building Web APIs often face tricky situations like ensuring secure access, validating data correctly, and making sure everything communicates smoothly. Solving these challenges leads to powerful APIs that make sharing information between different systems easier and safer.

Creating a Web API to Share Information

We will be creating a Web API to share information about people that is stored in the Appian Database with three parties who can access it via a GET call on a specific URL.

• Log into Appian Designer from your Appian developer account.
• In Appian Designer, navigate to the “Objects” section.
• Create a new object by clicking on “New.”
• In the object creation menu, select “Web API”.

• You will be prompted to define your Web API. Provide a name and description for your API.

• Configure the endpoints by specifying the URLs or URIs used to access resources or perform actions through your API.
• Specify the data inputs (request parameters) and outputs (response data) for each endpoint within the Web API.

• Define the structure of the data that your API will send and receive.
• For each endpoint, implement the logic using Appian expressions, business rules, or by integrating with external data sources or services. Ensure the logic meets the endpoint’s requirements.

• After configuring your Web API, save your changes.

• Use the built-in Appian testing capabilities or external tools like Postman to test your Web API. Send requests to the defined endpoints and verify the responses.

In conclusion, following these steps, you can efficiently create and configure a Web API in Appian, ensuring it is ready for use and thoroughly tested for seamless integration with other systems. For more information, you can visit documentation.