Low-Code Application Development with Appian: The practitioner’s guide to high-speed business automation at enterprise scale using Appian

Low-Code Application Development with Appian
Contributors
About the author
About the reviewer
Preface
    Who this book is for
    What this book covers
    To get the most out of this book
    Download the example code files
    Download the color images
    Conventions used
    Get in touch
    Share Your Thoughts
Section 1: No-Code with Appian Quick Apps
Chapter 1: Creating an Appian Quick App
    Login and first contact with Appian
    Naming your Quick App
    Defining case data
    Setting permissions and generating an app
    Testing your app
    Summary
    Further reading
Chapter 2: Features and Limitations of Appian Quick Apps
    Managing record items in Quick Apps
    Managing tasks in Quick Apps
    Managing documents in Quick Apps
    Reporting in Quick Apps
    Modifying a Quick App
    Summary
Chapter 3: Building Blocks of Appian Quick Apps
    The basic workings of the Appian Designer environment
    Introduction to Appian Records
        Source & Default Filters
        Tempo
        List
        User filters
        Views
        Related Actions
        Performance
    Checking the Appian process models
    Learning about Appian interfaces
    Understanding Appian expression rules
        Object dependencies in Appian
    Summary
Chapter 4: The Use Cases for Appian Quick Apps
    Managing conference attendees
    Advanced task management
    The simple software development process
        Requirements management
        Product backlog
    Summary
Section 2: A Software Project with Appian
    The meaning of software development
    Software development using Appian
    Starting a software project using Appian
Chapter 5: Understanding the Business Context
    The people at Tarence Limited
        Christine – Business Owner
        Paul – Product Owner
        Melanie – Key Stakeholder
        Igor – IT Architect
        Beth – Key User
        You
    Discovering the IT landscape
        Business architecture
        Information architecture
        Technology architecture
    Motivation for the project
        Cost reduction
        Scaling up
        Team upskill
    Implementing low-code Business Process Management (BPM)
        The potential of Appian
        The expectations of companies
        Goals versus potential versus change
    Summary
Chapter 6: Understanding Business Data in Appian Projects
    Learning objectives
    Main business data entities
    Adding relations
        One-to-one
        One-to-many
        Many-to-many
    Adding details
        UID
        External IDs
        Name
        Description
        Created
        Modified
        Status
    Adding application data
        Process data
        Audit trail
        Monitoring
        Reporting
    Finding the right level
    Summary
Chapter 7: Understanding Business Processes in Appian Projects
    Learning objectives
    Useful methodologies
        Business-Process-Modeling-Notation
        Five-Whys
        Ishikawa diagram
        SIPOC
    As-is process
    Software-driven processes
    Task-driven processes
    Case management
        Basic principles
        Theses
    To-be process
    Summary
Chapter 8: Understanding UX Discovery and the UI in Appian Projects
    Understanding UX discovery
        User experience
        User interface
    Supporting people doing their tasks
        Scope
        Information
        Input
        Orientation
    Understanding management needs
    A wireframing introduction and tools
        Understanding wireframes
        The benefits of wireframes
    Designing screens in an Appian context
        Record
        Task
        Report
    Summary
Section 3: Implementing Software
Chapter 9: Modeling Business Data with Appian Records
    Creating the application object
    Custom data types
        Creating the CDT
        Creating more fields
        Creating more CDTs
    Data stores
        Creating the data store
        Managing the database
    Records
        Creating records
    Relationships
        Adding many-to-many relations
    Best practices
    Summary
Chapter 10: Modeling Business Processes in Appian
    A first simple process
        Creating the model
        Adding a process variable
        Adding the start form
        Testing the model
    Persisting data
    Adding the process to the record
        Assigning the process
        Cancel behavior
    Adding related actions and record actions
        Updating a record
        Deleting a record
    Completing the process
        Modifying the Create Invoice interface
        Setting up the case
        Assigning the first task
    Best practices
        Process modeling habits
        Process data flow
    Summary
Chapter 11: Creating User Interfaces in Appian 
    Technical requirements
    Creating interfaces from scratch
        Record views
        Process start forms
        User Input Task
        Sites
    Adding validation logic
        Date validation
        Range check
    Creating dynamic interfaces
    Creating reusable interface components
        This happens next
        Formatted amount field
    Best practices
        User experience
        Expression mode versus design mode
        Performance view
        Variable flow
        Local variables
        Rule inputs
        Reusable components 
        Debugging
    Summary
Chapter 12: Task Management with Appian
    Technical requirements
    Assigning tasks
        Reassignment behavior
        Re-assignment privileges
        Process model security and reassignment
    Dynamic task assignment
        Assigning tasks using process variables
        Assigning tasks using decision tables
    Escalations and exceptions
        Escalations
        Exceptions
    Process reports
        Creating a process report
        Display a process report
    Completing the process
        An interface for Clarify Invalid Invoice
        Modify initial verification
        The task and interface for Assign Invoice
        Logic to finalize the invoice and the case
    Best practices
        Using groups
        Task due date
        Task exceptions
    Summary
Chapter 13: Reporting and Monitoring with Appian
    Data sources and preparation
        Monitoring process activity
        Reporting
        Periodic data measurement
        Storing measurements
        Preparing the case record
        Measuring data
        Completing the measuring process model
    Aggregating data
        Cases over time
        Current case status
    Visualizing data
        Status over timeline chart
        Case status donut chart
        Case grid
        Billboard cards
    Adding interaction
    Best practices
        Stakeholder groups
        Historic reports
        Make reports interactive
        Composing reports
    Summary
Section 4: The Code in Appian Low-Code
Chapter 14: Expressing Logic with Appian
    Decisions – simple logic in a visual designer
        Input configuration
        Output configuration
        Decisions summary
    Constants – managing literals and application configuration
        String literals
        Groups
        Data store entities
        Documents
        Process models
        Constants summary
    Expressions – constant logic expressed in text
        Programming paradigms
        Inputs, locals, and outputs
        Data types
        Dictionaries and maps
        Working with lists
    Best practices
    Summary
Chapter 15: Using Web Services with Appian Integrations
    Technical requirements
    HTTPS, authentication, and JSON
        HTTPS
        HTTP request
        HTTP response
        Security
        JSON
    OpenAPI basics
        servers
        paths
        components
        OpenAPI summary
    Connected systems and integrations
        Creating a web service
        Integrating the web service
    Using integrations
    Best practices
        Validate incoming data
        Wrapping integrations
        Security
    Summary
Chapter 16: Useful Implementation Patterns in Appian
    Technical requirements
    Solution patterns
        Process versus case management
        Recording audit trails
        Record security
        CDT first versus database first
        Waiting for external triggers
    Process patterns
        Creating process chains
        Using subprocesses
        Multiple Node Instances
        Building loops in processes
    Interface patterns
        Building wizards
        Tabbed interfaces
        Designing for reusability
        Expression rule patterns
        Managing collections of constants
        Universal null check
        Nested indexing
        Validating IBANs
        Flexible looping predicate
        Additional Appian modules
        IDP
        RPA
        Process mining
        Appian Portals
    Summary
    Why subscribe?
Other Books You May Enjoy
    Packt is searching for authors like you
    Share Your Thoughts