Understanding and Using Smart Process Builder

Learning Team

Overview

Smart Process Builder is an AI-powered tool that helps Practifi Administrators quickly and efficiently create complex process types. Instead of manually building each task in a process, you can describe what you want in natural language, and the AI will generate a process preview with a flowchart and proposed tasks, actions, and outcomes, allowing you to evaluate the suggested structure before any configuration is committed.

This tool converts plain English prompts into suggested workflow items, reducing manual effort and speeding up process creation while offering suggestions to improve your process structure. This article provides an overview of Smart Process Builder's features and guidance on using it effectively.

Please note: Smart Process Builder is a part of our Practifi Intelligence add-on. To request access to this feature, please reach out to your Client Success Manager or Practifi contact. Enabling Smart Process Builder requires signing additional data processing agreements as part of our partnership with our AI provider.

Accessing Smart Process Builder
Using Smart Process Builder
Modifying an Existing Process
Best Practices
- Sample Prompts
Considerations
Limitations

Accessing Smart Process Builder

Once enabled, you can access Smart Process Builder by navigating to the Settings app:

Click the App Launcher in the upper-left corner of the Practifi screen, then select Settings.
In the Settings app, click the caret next to the Navigation menu, scroll down, and select Smart Process Builder.

Please note: For existing Practifi organizations, Smart Process Builder appears as the last item in the navigation list to preserve any customizations you may have made.
Alternatively, on the Process Types page in the Settings app, click the Smart Process Builder button to open the tool.

Using Smart Process Builder

Describe Your Process

When you first open Smart Process Builder, you'll see a prompt asking, "What would you like to build?"

To write an effective prompt, consider these tips:

Be specific and use terms like "Tasks," "Stages," and "Outcomes"
Break your process into clear steps or use bullet points
Use consistent naming and explicit instructions
Use positive language, i.e., "Do this" instead of "Don't do that"

Please note: For additional guidance on writing prompts, reference the Best Practices section below and our article on AI Basics and Best Practices.

After entering your prompt, click Submit to proceed to the next step.

You'll see a loading spinner with status messages while the AI processes your request.

Review and Refine Your Process

Next, you'll see the process review and configuration screen, which has a two-column layout.

On the left-hand side of the screen is the Process Preview area. This displays an interactive flowchart of the AI's suggested process, including tasks, branching logic, and outcomes. You can click the rectangular task nodes to view more information in the Task Details area on the right-hand side of the screen. Some controls allow you to zoom, refresh, and download a .png version of the diagram.

The right-hand side of the screen has the following areas:

Refine Your Prompt: Here, you can edit your original input to improve the generated process and click Submit to regenerate the process diagram and suggestions
Task Details (appears when you click a task node): This read-only form displays the following information:
- Subject: Task title
- Priority: AI-generated default
- Status: AI-generated default
- Order: Sequential numbering
- Description: AI-generated summary
- Actions Table (if applicable): Shows the Action Label, Action Type, and Outcome in a responsive three-column format.
Suggestions: This panel displays AI-generated guidance on improving your prompt, so you can refine the process design before it's built. All sections are collapsed by default. Click a heading to expand it and view the suggested content. Only one section can be expanded at a time.
- Writing Tips: Improves prompt clarity, structure, and effectiveness. Focuses on phrasing, specificity, and completeness.
- Industry Expertise: Provides industry-specific standards and best practices. Recommendations are based on keywords in your prompt.
- Process Recreation Prompt: Shows a reworded, more structured version of your prompt.

If you want to use the process recreation prompt, click the Copy icon under the heading to copy the enhanced prompt to your clipboard. A confirmation message appears.

You can then scroll up and paste the enhanced prompt into the Refine Your Prompt area. Optionally, you can make additional edits in the text box before clicking Submit.

Please note: When entering content into the Refine Your Prompt area, be sure to click Submit before clicking Save & Finish. Failure to do so can result in an error.

Finalize Your Process

At the bottom of the screen, you can click the Reset button to clear your inputs and go back to the starting screen.

If you're ready to generate your new process type, click Save & Finish.

After clicking Save & Finish, you'll see a confirmation screen.

Click Open Process to view the generated process in a new tab. Alternatively, you can click Start Again to return to the initial prompt screen in Smart Process Builder.

You can also find your new process on the Process Types page in the Settings app.

Modifying an Existing Process

Smart Process Builder helps you create new process types from natural language instructions. It does not support editing existing process types directly. However, you can use it to build a modified version of an existing process by extracting the current configuration, translating it into plain language, and then prompting Smart Process Builder to recreate it with whatever changes you need.

This approach follows a best practice for any significant process change: rather than editing a live process type, create a new version. That way, any processes already in flight are completed under the original configuration, and the updated version takes effect only for new launches.

The overall workflow is:

Get the Record ID of the existing Process Type record.
Run a script to extract its full configuration.
Use an AI tool (such as Claude or ChatGPT) to translate the data into natural-language instructions.
Paste those instructions into Smart Process Builder along with your desired changes.
Manually configure any elements Smart Process Builder does not support (e.g., checklist items, execution rules, and Active Forms).
Deactivate the old process type and make the new one visible to end users.

Step 1: Get the Process Type Record ID

From the Settings app, open the Process Type record you want to modify. It opens in a new tab.
Copy the 18-character Record ID from the URL bar. The ID appears after the last forward slash in the URL and starts with the letter a.
Paste the Record ID into a Notepad file for use in Step 2.

Step 2: Extract the Process Configuration

This step runs a script that reads the full configuration of the existing process type and emails you a text file containing all of its stages, tasks, branching logic, outcomes, and checklist items.

Click the Settings cog and select Developer Console.
Click the Debug menu and select Open Execute Anonymous Window (or click <CTRL>+E).

Copy and paste the following script into the Enter Apex Code window. Replace PASTE_RECORD_ID_HERE with the Record ID from Step 1.

// ============================================================
// Process Type Extractor for Smart Process Builder
// Replace the ID on the next line, then Execute.
// The script emails the export file to you as an attachment.
// ============================================================
Id ptId = 'PASTE_RECORD_ID_HERE';

// --- Process Type ---
practifi__Process_Type__c pt = [
    SELECT Id, Name, practifi__Description__c, practifi__Related_To__c,
           practifi__Active__c, practifi__Assignment_Type__c,
           practifi__Business_Role__c, practifi__Servicing_Team_Role__c,
           practifi__Task_Due_Date_Basis__c, practifi__Stage__c,
           practifi__Order__c, practifi__Group__c
    FROM practifi__Process_Type__c WHERE Id = :ptId
];

// --- Stages ---
List<practifi__Process_Stage__c> stages = [
    SELECT Id, Name, practifi__Order__c, practifi__Group__c
    FROM practifi__Process_Stage__c
    WHERE practifi__Process_Type__c = :ptId
    ORDER BY practifi__Order__c
];

// --- Tasks ---
List<practifi__Process_Task__c> tasks = [
    SELECT Id, Name, practifi__Subject__c, practifi__Description__c,
           practifi__Code__c, practifi__Task_Type__c, practifi__Order__c,
           practifi__Assignment_Type__c, practifi__Business_Role__c,
           practifi__Servicing_Team_Role__c, practifi__Priority__c,
           practifi__Suppress_At_Launch__c,
           practifi__Entity_Relationship_Type__c,
           practifi__Enable_for_Portal_Users__c
    FROM practifi__Process_Task__c
    WHERE practifi__Process_Type__c = :ptId
    ORDER BY practifi__Order__c
];
Set<Id> taskIds = new Map<Id, practifi__Process_Task__c>(tasks).keySet();

// --- Actions (branching logic) ---
List<practifi__Action__c> actions = [
    SELECT Id, Name, practifi__From_Task__c,
           practifi__From_Outcome__c, practifi__From_Outcome__r.Name,
           practifi__Action_Type__c,
           practifi__Create_Task__c, practifi__Create_Task__r.practifi__Subject__c,
           practifi__Process_Stage__c, practifi__Process_Stage__r.Name,
           practifi__Order__c, practifi__Group__c
    FROM practifi__Action__c
    WHERE practifi__From_Task__c IN :taskIds
];

// --- Outcomes (decision points on tasks) ---
List<practifi__Task_Outcome__c> outcomes = [
    SELECT Id, Name, practifi__Process_Task__c,
           practifi__Process_Task__r.Name
    FROM practifi__Task_Outcome__c
    WHERE practifi__Process_Task__c IN :taskIds
];

// --- Checklist Items (subtasks within tasks) ---
List<practifi__Preset_Checklist_Item__c> checklists = [
    SELECT Id, practifi__Label__c, practifi__Order__c,
           practifi__Required__c, practifi__Type__c,
           practifi__Process_Task__c,
           practifi__Process_Task__r.Name
    FROM practifi__Preset_Checklist_Item__c
    WHERE practifi__Process_Task__c IN :taskIds
    ORDER BY practifi__Process_Task__c, practifi__Order__c
];

// --- Build file content ---
String output = '=== PROCESS TYPE EXPORT FOR SMART PROCESS BUILDER ===\n';
output += 'Process: ' + pt.Name + '\n';
output += 'Exported: ' + DateTime.now().format() + '\n';
output += '====================================================\n\n';
output += 'INSTRUCTIONS: Upload or paste this file into an AI tool\n';
output += '(Claude, ChatGPT, etc.) and ask it to describe the process\n';
output += 'in natural language. Then feed that description to the Smart\n';
output += 'Process Builder to recreate or modify the process.\n\n';
output += '--- PROCESS TYPE ---\n';
output += JSON.serializePretty(pt) + '\n\n';
output += '--- STAGES ---\n';
output += JSON.serializePretty(stages) + '\n\n';
output += '--- TASKS ---\n';
output += JSON.serializePretty(tasks) + '\n\n';
output += '--- ACTIONS ---\n';
output += JSON.serializePretty(actions) + '\n\n';
output += '--- OUTCOMES ---\n';
output += JSON.serializePretty(outcomes) + '\n\n';
output += '--- CHECKLISTS ---\n';
output += JSON.serializePretty(checklists);

// --- Email the file to yourself ---
Messaging.EmailFileAttachment efa = new Messaging.EmailFileAttachment();
efa.setFileName('process-export-' + pt.Name.replaceAll('[^a-zA-Z0-9]', '-') + '.txt');
efa.setBody(Blob.valueOf(output));

Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();
email.setToAddresses(new List<String>{ UserInfo.getUserEmail() });
email.setSubject('Process Export - ' + pt.Name);
email.setSaveAsActivity(false);
email.setPlainTextBody(
    'Process Type export attached for: ' + pt.Name + '.\n\n'
    + 'Upload this file to an AI tool (Claude, ChatGPT, etc.) and ask\n'
    + 'it to describe the process in natural language. Then feed that\n'
    + 'description to the Smart Process Builder to recreate or modify\n'
    + 'the process.'
);
email.setFileAttachments(new List<Messaging.EmailFileAttachment>{ efa });
Messaging.sendEmail(new List<Messaging.SingleEmailMessage>{ email });

System.debug('Done! The export file has been emailed to: ' + UserInfo.getUserEmail());

Please note: Make sure to leave the single quotes in the query and only replace PASTE_RECORD_ID_HERE with the Record ID.

Click Execute.
Check your email inbox for a message titled "Process Export - [Process Name]." Download the attached text file.

Please note: This script uses the standard practifi__ managed package namespace. If you encounter a compilation error such as "sObject type not found," your organization may be using a different namespace or may have unmanaged objects. Check the actual object API names in Object Manager.

Step 3: Translate the Configuration Into Natural Language

The export file from Step 2 contains raw configuration data in JSON format. Before you can use it in Smart Process Builder, you need to convert it to a natural-language description. An AI tool like Claude or ChatGPT can do this translation for you.

Open the AI tool of your choice (for example, claude.ai or chat.openai.com).

Upload the export file from Step 2, then enter the following prompt. Replace the bracketed placeholder at the end with the specific changes you want to make.

I have a JSON export of an existing Practifi Process Type and all its
related configuration. I need you to analyze this data and produce a
clear, natural language description of the process that could be used
as instructions for the Smart Process Builder to recreate it.

Your description should cover:
1. The overall purpose of the process and what entity types it applies to
2. Each stage in order, and what it represents
3. Every task within each stage — its name, description, assignment
   approach, and any checklist items
4. The branching logic — which task outcomes lead to which next tasks
   or stage transitions
5. Any special configuration like suppressed-at-launch tasks, portal
   visibility, or entity relationship scoping

Write this as a set of clear instructions someone could follow to
build this process from scratch. Use natural, conversational language
— not field names or IDs.

---

Now, in addition to recreating the above process, I want to make the
following modifications to the new version:

[DESCRIBE YOUR DESIRED CHANGES HERE]

Review the AI-generated description. It should read as a clear set of instructions that describes the full process, with your requested changes woven in.

Step 4: Build With Smart Process Builder

Open Smart Process Builder from the Settings app (see the Accessing Smart Process Builder section above for instructions).
Copy the output from Step 3 and paste it into the prompt field.
Click Submit to generate the process preview.
Review the flowchart and task details. If anything needs adjustment, use the Refine Your Prompt area to describe the changes and click Submit again. You can iterate as many times as needed.
When you're satisfied with the result, click Save & Finish.

Step 5: Add Manual Configuration

Smart Process Builder creates the core process structure: stages, tasks, branching logic, task sequencing, and stage transitions. However, it does not currently generate all types of process configurations. After the process is built, you may need to manually add any of the following elements that were present in the original:

Checklist items: Step-by-step checklists attached to individual tasks. The export file from Step 2 includes checklist data you can reference.
Rule-based actions: Advanced conditional logic beyond simple outcome-based branching.
Active forms: Forms linked to tasks for data capture during process execution.
Save to Related Record actions: Field update mappings on related entities.
Portal configuration: Portal visibility settings, labels, descriptions, and ordering.

Think of Smart Process Builder as handling the structural foundation of the process, which is typically the most time-consuming part to build manually. The task-level configuration details are quicker to add once the skeleton is in place. For a full list of unsupported features, see the Limitations section below.

Step 6: Complete the Swap

Once your new process type is built and you have verified it works as expected:

Deactivate the old process type: Open the original process type record and uncheck the Visible checkbox. This prevents new processes from being launched under the old definition. Any processes already in flight will continue to completion under the original structure.
Activate the new process type: On the new process type record, confirm the Visible checkbox is checked and that the correct Related To entities are configured so the process appears in the right launch contexts.
Test the new process: Launch a test process using the new process type to confirm it behaves as expected before rolling it out to users.

Tips

Start simple, then iterate. Smart Process Builder works best with clear, sequential instructions. Focus on structure and logic first, then refine details in subsequent conversational turns.
Use the Flow Diagram to validate. After Smart Process Builder creates the new process, open its Flow Diagram and compare it against the original to catch structural differences.
For minor changes, skip the extraction. If you only need to add a task or change an outcome, you may not need the full extraction workflow. Describe the existing process from its Flow Diagram, note the specific change, and let Smart Process Builder handle the rest.

Best Practices

Keep these tips in mind when working with Smart Process Builder:

Use Clear, Prescriptive Language

Use specific terms such as "Stages," "Tasks," "Actions," and "Outcomes," with clear descriptions.
Be explicit and use clear phrasing to distinguish between process and task assignments:
- "Assign this task to [User Name]"
- "Assign this process to [Team/Role]"
- Or use Specify Now for runtime assignment.
When defining process assignments, clearly label them as such or use structured headers, such as "Task 1" and "Task 2," to avoid confusion with task-level assignments.
CAPITALIZE important terms to emphasize critical components in the prompt, helping AI better understand your prompt priorities.

Use Positive and Affirmative Language

Ask for what you want rather than what you don't want. Clear, positive instructions yield better AI outputs.

Include Context

Describe who the user is, what they know, and how they should act to give the AI proper context.

Structure Your Prompts Thoughtfully

Break multi-step processes into bullet points or numbered lists to improve the accuracy of the flowchart.

Example:

Task: Collect KYC documents
Task: Review risk profile
Task: Set stage to 'KYC Complete'

Keep instructions simple and avoid combining multiple actions into one sentence. For complex tasks with multiple actions leading to a single outcome, clearly separate each step. Define the task and outcome, and list each action clearly. This helps avoid confusion or misconfiguration.

Define Time and Process Elements Explicitly

Use valid date formats (e.g., "+5 business days") to ensure due dates are applied correctly. Invalid or vague inputs may result in blank or incorrect fields.

Explicitly Define Custom Elements

When using custom stages, assignments, or dependencies, clearly specify their names and positions (e.g., "Add a custom stage 'Client Review' after Task 2"). The AI does not infer beyond standard templates, so all custom elements must be explicitly defined.

Reference Fields With Context

For lookup fields (e.g., Service Type), use values that are frequently accessed in your organization. Avoid rarely used values, as the AI typically selects only from the top 10 most accessed active records. If a value isn't among these, it may not be recognized during configuration.

Use Suggestions

Use the Process Recreation Prompt to refine brief inputs for clarity. For complex processes, treat it as a starting point and revise your prompt manually.

To reflect recent changes, click Submit to update the Suggestions area.

Save and Iterate

Always save your original prompt externally before previewing in case revisions are needed.

If the diagram doesn't render correctly, click Submit again; this often refreshes the output and improves the result.

Sample Prompts

There are two approaches to composing Smart Process Builder prompts: using natural language to describe the process you want and refining the output until it meets your needs, or prompting with specific, pre-defined requirements gathered as part of your team's process. Here are examples of each prompting type:

Example 1: Simplified Prompt

Scenario: You have an idea for a custodian onboarding process, but you haven't mapped it out. Rather than listing all the tasks and outcomes in an outline format, you can use natural language to describe the process you want to create.

Prompt: Can you help me set up a process for onboarding custodians? There are a bunch of checks and approvals that need to happen before we can activate them, and they involve different teams, like client services and some internal reviewers. Sometimes we need to send emails to clients, and sometimes we need approvals from senior people, depending on certain conditions. There are also cases where we need to check financial details or risk factors. Eventually, if everything looks good, the client or matter gets activated. If not, it might get rejected. I'm not sure how all the steps should be structured, but I'd like the process to guide people through what needs to happen.

Please note: After entering a prompt like the one above, you should consult the Process Recreation Prompt suggested by Smart Process Builder. Copying and pasting it into the Refine Your Prompt area and then regenerating can improve the output.

Example 2: Complex Prompt

Scenario: Your firm has a complex workflow for bringing on new custodians. After interviewing stakeholders, you construct a detailed map of the workflow, including stages and outcomes.

Prompt: Create a comprehensive process named "Custodian Onboarding Process" with the following description: "A process to onboard new custodians, ensuring all necessary checks and approvals are completed before activation." This process should relate to the Client, Service, and Member.

Configure the following custom stages for this process:

Not Started
Inception Done
Verification Done
Approvals
Send to Client
Client/matter activated
Rejected

Create the following tasks:

Task 1: New Client/Matter Inception

Type: Onboarding
Priority: Normal
Description: Initiate the inception of a new client or matter
Actions:
- Set process stage to "Inception Done"
- Create task "Enter and extract client/matter inception"

Task 2: Enter and Extract Client/Matter Inception

Type: Onboarding
Priority: Normal
Description: Enter and extract necessary client/matter information
Actions:
- Set process stage to "Verification Done"
- Create task "Verification and approval"

Task 3: Verification and Approval

Type: Review
Priority: Normal
Description: Verify and approve client/matter details
Actions:
- Set process stage to "Approvals"
- Create task "Case Control Review"

Task 4: Case Control Review

Type: Review
Priority: Normal
Description: Conduct the first case-control review
Action: Create task "Send Email to Client"

Task 5: Send Email to Client

Type: Client Communication
Priority: Normal
Description: Send a notification email to the client
Create two Outcomes called "Client Responds" and "No Response".
Actions:
- If the Outcome is Client Responds, then create the task "Launch Client input form"
- If the Outcome is No Response, then create the task "Check High risk?"

Task 6: Client Input Form

Type: Client Communication
Priority: Normal
Description: Collect required input and documentation from the client
Action: Create task "Launch Case-control review"

Task 7: Check High Risk?

Type: Review
Priority: Normal
Description: Assess if the client presents high-risk factors
Create two Outcomes called "High Risk" and "Low Risk".
Actions:
- If the Outcome is High Risk, then create the task "Case Control Review"
- If the Outcome is Low Risk, then create the task "Client matter activated"

Task 8: Case Control Review

Type: Review
Priority: Normal
Description: Conduct the case-control review
Action: Create task "Launch Client input approval"

Task 9: Client Input Approval

Type: Review
Priority: Normal
Description: Review and approve the client input received
Action: Create the task "Launch Client Matter Activated"

Task 10: Client Matter Activated

Type: Onboarding
Priority: Normal
Description: Finalize and activate the client matter in the system
Actions: Set process stage to "Client/matter activated"
Assignment Instructions:
- Assign the overall process to the Onboarding Team
- Tasks requiring approvals should be assigned to the respective managers/executives
- Client communication tasks should be assigned to the Client Services Team

Considerations

Here are some things to keep in mind about this feature:

Smart Process Builder uses two AI models:
- GPT-4o converts prompts into JSON-based process flows.
- GPT-4o mini generates content for the Suggestions area.
Suggested processes use only four default process stages:
- Not Started
- In Progress
- Completed
- Cancelled
Task priorities and statuses are automatically generated.
Advanced configurations, such as task actions that utilize public groups and dependency groups, must be manually modified after generation.
Smart Process Builder should only be accessed from within the Settings app. While it is technically possible to launch Smart Process Builder from the App Launcher, using it outside the Settings app can lead to unexpected behavior and limited functionality.

Limitations

Unsupported Features

Smart Process Builder does not support the following features at this time:

Active Forms
Rule-Based Actions
Checklist items
Salesforce Flows
Dependency groups for actions

Rule-Based Actions and Checklist items can be added manually after the process type is generated.

Token and Length Limits

Smart Process Builder has token limits. If a prompt exceeds these limits, it may cause graph errors or prevent the process from being created. In such cases, content in the Suggestions area may appear truncated.

The Process Recreation Prompt feature is intended for general, low-detail prompts. Using it with highly specific input may lead to incomplete or undesired results.

AI Interpretation Limitations

The Assignment Type field on Process Type and Process Task records controls the visibility of related fields (e.g., Servicing Team Role), but the AI does not populate these conditional fields. Manual input is required post-generation.

Custom stages must be explicitly defined; the AI does not infer them.

Action labels may not match the actual configured behavior. For example, a label might say "Set Process Stage to In Progress" while the actual stage is "Initial Communication", which can confuse review or troubleshooting.

Prompt and Output Handling

Prompts are not autosaved. Refreshing or generating a new preview will erase the original input. We recommend backing up your prompt outside of Smart Process Builder.

Long or vague prompts may be truncated or fail due to token limits.

Special characters and symbols such as /, <, and & may not render in the diagrams, but they are stored in the configuration. Use plain language or reword where possible to avoid rendering issues.

Output Configuration Gaps

When the process type is generated, only the first process task is set by default not to be suppressed at launch; all other tasks require manual adjustment, even if the prompt specifies otherwise. The AI model does not support launching multiple tasks simultaneously.

Dependency groups for actions cannot be configured via a prompt.

Additionally, task actions such as Send a Notification do not retain public group references and must be configured manually.

Risk of Redundant Actions

By default, the AI sets the Process Stage to In Progress for any non-initial task. If the prompt also includes outcome-based logic that sets a different stage, it can result in duplicate or conflicting actions. Branching conditions in prompts may lead the AI to create two actions for the same task.