Low-Code Application Development with Appian

Table of contents

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