Appian

Overview

Appian provides a low-code platform for developing enterprise applications and automating business processes. The platform integrates capabilities such as process modeling, robotic process automation (RPA), intelligent document processing (IDP), and a data fabric to support end-to-end workflow automation. Its visual, model-driven development environment is designed to accelerate application delivery, allowing developers and business users to collaborate on building solutions without extensive manual coding.

The core of Appian's offering is the Appian Platform, which unifies data from various systems into a single view through its Data Fabric. This approach aims to provide a comprehensive operational picture, facilitating better decision-making and process orchestration. For instance, a common use case involves automating customer onboarding processes by integrating data from CRM systems, identity verification services, and internal databases, then orchestrating the necessary human and automated tasks.

Appian is typically adopted by organizations seeking to modernize legacy systems, streamline operational workflows, and develop custom applications more quickly than traditional coding methods. Its focus on intelligent automation extends to handling unstructured data through IDP and automating repetitive tasks with RPA. The platform's architecture supports deployment in cloud environments, including AWS, Azure, and Google Cloud, or on-premises, providing flexibility for enterprise IT strategies. The Appian Community Edition offers a free tier for individual developers to experiment with the platform's features and develop solutions.

The platform's emphasis on low-code development is intended to reduce the time and resources required for application creation and modification. This can be particularly beneficial for organizations facing a shortage of skilled developers or needing to respond rapidly to changing business requirements. For example, a Forrester report highlighted that low-code platforms can accelerate application development by up to 10x compared to traditional methods, enabling faster time-to-market for new digital initiatives The Total Economic Impact Of The Appian Low-Code Platform. Appian’s approach also includes governance tools to manage applications and processes at scale, addressing enterprise requirements for security and compliance.

Key features

• Appian Platform: A unified low-code environment for building business applications and automating workflows. It provides visual development tools, pre-built components, and a drag-and-drop interface.
• Data Fabric: Integrates data from disparate systems without requiring data migration, creating a unified view for applications and processes. This feature aims to simplify data access and management across the enterprise.
• Process Mining: Tools to analyze existing business processes, identify bottlenecks, and discover opportunities for automation and optimization. This helps organizations understand actual process execution.
• Robotic Process Automation (RPA): Capabilities to automate repetitive, rule-based tasks performed by human users, often involving interactions with existing legacy systems.
• Intelligent Document Processing (IDP): Uses AI and machine learning to extract, classify, and process information from unstructured documents (e.g., invoices, forms), converting it into structured data for automated workflows.
• Workflow Automation: Orchestrates human and automated tasks across various systems, enforcing business rules and ensuring compliance.
• Mobile Application Development: Supports the creation of mobile-ready applications directly from the low-code platform, accessible on various devices.
• Cloud Deployment: Can be deployed on major cloud providers (AWS, Azure, Google Cloud) or on-premises, offering deployment flexibility.

Pricing

Appian offers custom enterprise pricing based on specific organizational needs and usage. A free community edition is available for individual developers.

Common integrations

• Database Connectors: Integration with various databases such as SQL Server, Oracle, MySQL, and PostgreSQL for data access and manipulation Appian Database Connected System documentation.
• RESTful APIs: Ability to consume and expose RESTful web services for integration with external systems and applications Appian Web API documentation.
• SAP: Connectors for integrating with SAP ERP systems to automate processes involving financial data, supply chain, and HR Appian SAP Connected System.
• Salesforce: Integration with Salesforce CRM to synchronize data and automate customer-related workflows Appian Salesforce Connected System.
• Microsoft (Azure, Dynamics 365, SharePoint): Connectors and capabilities for integrating with various Microsoft services, including Azure cloud services, Dynamics 365 for business applications, and SharePoint for document management Appian Microsoft Azure Connected System.
• Robotic Process Automation (RPA) Bots: Integration with Appian's own RPA bots and potentially third-party RPA solutions to automate desktop tasks.

Alternatives

• OutSystems: A low-code development platform focusing on full-stack application delivery and enterprise-grade scalability OutSystems homepage.
• Mendix: Another low-code platform offering tools for rapid application development, focused on fostering collaboration between business and IT Mendix platform overview.
• Pega: Known for its intelligent automation and customer engagement solutions, providing a low-code platform for building complex business applications and managing customer journeys Pega Systems.

Getting started

Getting started with Appian typically involves signing up for the Appian Community Edition, which provides a free development environment. This allows users to explore the platform's visual development tools and build simple applications.

The following steps outline a basic approach to creating a new application in Appian:

1. Sign up for Appian Community Edition: Access the free tier to get your development environment.
2. Log in to your Appian environment: Navigate to your assigned Appian URL and log in with your credentials.
3. Create a new application: From the Appian Designer, initiate the creation of a new application. This typically involves naming the application and defining its security settings.
4. Define your data model (Record Type): Create a Record Type to represent the data your application will manage. For example, if building a task management app, you might create a 'Task' Record Type with fields like 'Task Name', 'Description', 'Due Date', and 'Status'.
5. Build an interface (User Interface): Design the user interface for your application using Appian's drag-and-drop interface designer. This involves adding components like text fields, buttons, and grids to display and collect data.
6. Create a process model (Workflow): Design the workflow that defines the logic and steps of your application. For instance, a task management workflow might include steps for 'Submit Task', 'Assign Task', and 'Complete Task'.
7. Deploy and test: Once the application components are built, deploy the application within your environment and test its functionality.

While Appian is a low-code platform, understanding fundamental application development concepts and business process design principles can facilitate more effective use of its capabilities. The Appian documentation portal provides detailed guides and tutorials for various features and use cases Appian documentation.

-- This is not executable code, but represents the design steps in Appian's visual editor.
-- It illustrates the conceptual flow for creating a simple 'Task Management' application.

-- 1. Create a New Application
--    Name: "Task Management App"
--    Prefix: "TM"

-- 2. Define a Record Type for Tasks
--    Record Type Name: "Task"
--    Source: Database Table (e.g., "TM_Task") or Appian Process Variable
--    Fields:
--      - id (Number, Primary Key)
--      - name (Text)
--      - description (Paragraph Text)
--      - dueDate (Date)
--      - status (Text, e.g., "New", "In Progress", "Completed")
--      - assignedTo (User)

-- 3. Design User Interfaces (Interfaces)
--    a. Interface: "TM_CreateTaskForm"
--       - Components: Text Field (Name), Paragraph Field (Description), Date Field (Due Date), User Picker (Assigned To), Button (Submit)
--    b. Interface: "TM_TaskListReport"
--       - Components: Grid (displaying Task Record Type data), Filters (Status, Assigned To)
--    c. Interface: "TM_TaskDetailsView"
--       - Components: Display Field (Name, Description, Due Date, Status, Assigned To), Button (Mark Complete)

-- 4. Create a Process Model (Workflow)
--    Process Model Name: "TM_ManageTaskProcess"
--    Start Node: (User Start Form: TM_CreateTaskForm)
--    Flow:
--      - User Start Form (TM_CreateTaskForm)
--      - Script Task (Save Task data to Record Type)
--      - User Task (Assign Task to user, using TM_TaskDetailsView as form)
--      - XOR Gateway (Condition: Is Task Complete?)
--        - If Yes: End Node
--        - If No: User Task (Re-assign or Update Task)
--      - End Node

-- 5. Create a Site (User Portal)
--    Site Name: "Task Management Portal"
--    Pages:
--      - Page 1: "Create Task" (Linked to TM_CreateTaskForm interface)
--      - Page 2: "My Tasks" (Linked to TM_TaskListReport interface, filtered for current user)
--      - Page 3: "All Tasks" (Linked to TM_TaskListReport interface, no filter)