Each release, we continue to make major investments in Appian Records because we know that data is at the heart of every application. This release, we’re excited to show you our biggest investment yet with new features that make Appian Records the fastest and easiest way to leverage your enterprise data when you enable data sync.
Data sync allows Appian Records to operate with the benefit of onsite data by caching your source data in Appian. Much like how web browsers cache local data for faster queries, Appian can take advantage of the proximity to your synced data to enable better performance, and more powerful features that accelerate the entire design experience.
Data design is one of the most important parts of planning your application. Now, we make that design process easier and more flexible with (1) record type relationships and (2) custom record fields.
We know that your record types rarely exist in isolation. Instead, they are often related to other record types in your applications. Now, you can relate your record types using relationships to connect your data and then seamlessly reference this data throughout your applications.
Relationships can be established between record types with data sync enabled, which allows you to relate data from different source types, like Salesforce and a database table–going beyond traditional relationships you may establish in a database view.
Not only can relationships connect data more easily than a database view, they're also more performant. We tested large, complex reports that contained numerous references to related record data, and we've seen these reports perform 4X faster than reports backed by queries to tuned database schemas. This means that you can quickly and easily reference related data in your components and queries to build performant, information-dense interfaces.
When building reports, you may find your source data isn’t enough on its own. You often need to summarize your data, concatenate first and last names, or calculate the revenue and ROI from your existing data. Instead of creating elaborate queries to return these values, you can create custom record fields to store these values in the record type.
Custom record fields allow you to transform your existing record data into new fields on the record type. While you can use an expression to define these new fields, we are providing some reporting and data preparation templates that make it easy to configure the data you need.
Once you create a custom record field, you can reference these fields as quickly and easily as any other record field. Use your new custom record fields to build reports, grids, queries, and more.
Not only does data sync make it faster and easier to configure your data model, it makes configuring the entire record type faster. When you enable data sync, we can automatically configure parts of your record type for you.
When you leverage new record type relationships, it’s easy to incorporate your related record data in your user filters. By default, a user filter will be automatically configured whenever you define a new many-to-one relationship on your record type.
We’ve also updated the guided configuration experience to make it easier to use related record field values as your filter options. Simply create a user filter on a related record field, or a record field that defines a many-to-one relationship, and related record field values will automatically populate as filter options.
After setting up the data model for a record type, a common next step is to configure the interfaces to display your record data to users. To speed up your design time, all new record types with data sync enabled will have an option to automatically generate a Summary view based on the configured data model and relationships. Once you generate the interface, the expression will automatically populate the Summary view–no additional configuration needed.
Data sync continues to get better each release, and we are happy to announce that we’ve doubled the number of rows a record type can sync from a source–from 250,000 to 500,000 rows.
Since you can sync more data in Appian, we wanted to provide an easy way to track your sync progress. When you save a record type, a new progress bar appears on the Data Sync page of the record type that details how many rows of data have been synced in Appian. When syncing data from a database or Salesforce, you can also see how many total rows are in the queue to be synced.
Building applications and reporting with records is now easier than ever because of new design improvements, but it’s not just the design that’s better. The records themselves are also more performant.
This release, we’ve made the a!queryRecordType function faster for record types with sync enabled, and record types that use a data store entity. This can be up to 2X faster with small queries or queries that use direct record type field references.When you query related record data from a record type relationship, you’ll even see improved query performance compared to querying related data from a database view. We've seen reports perform 4X faster when referencing related record data compared to reports backed by queries to tuned database schemas.
We’ve also enhanced the record link component to make it 3X faster when using a direct record type reference. This means your users can now navigate to linked record views faster to more quickly gather important record insights. These performance improvements are automatically applied when you upgrade—no additional configuration required.
As with all performance measurements, the results depend on use case, hardware, and system load. The reported numbers here reflect a common use case under a moderate system load.
Beyond data sync, there are significant benefits to using record types to create powerful reports. Each release, we continue to provide new and easy ways to build reports using records, and this release is no exception. We’ve made it easier to display dates in charts and queries by introducing new grouping intervals.
Without creating extensive queries, you can easily group data by date, hour, minute, or even month and year together to easily show trends over time. We've also provided several out-of-the-box localized formats to meet common needs for displaying the resulting dates.
Appian allows you to orchestrate your people, systems, data, bots, and AI in a single workflow. This release, we've focused on enabling you to build RPA workflows faster through simpler modules and a reorganized configuration interface. Handle multiple process exceptions at once through RWM, and bypass manual reconciliation tasks in IDP when certain data conditions are met during extraction.
Appian's built-in document extraction features can automatically extract text values from digital and scanned documents alike, without using an outside vendor. We've also improved the table reconciliation experience to let you select a table area when it wasn't automatically identified.
You can use our new module to automate Windows applications entirely with low-code. It's easy to open and close specific applications, perform a variety of common or complex actions, and even switch between two open apps.
We've simplified our common RPA methods, making it easier to find what you're looking for and simpler to create automations regardless of operating system. Our new Operating System module shows the important, common actions a robot might take, while our Execution module makes it simple to print data to the logs or send a screenshot.
Want to do even more with low-code RPA? You can now download additional low-code libraries from the AppMarket and import them directly into the RPA console. No Java required. Take a look at the available RPA libraries for you to choose from.
Java developers, are you interested in seeing your name on the AppMarket by contributing to our growing list of low-code RPA libraries? We've streamlined the library export process as well, so it's easier than ever to go from developing a library to published listing.
We've updated the robotic process designer to improve your development flow. There's now just one save button at the top of the designer, making it easy to quickly save progress as you build the workflow. Similar to other object designers, Appian will also prevent you from leaving the page if you have unsaved changes. We've also moved robotic process variables and the workflow to the top of the page so you can focus directly on building automations without having to worry about less important configuration.
We've reduced the number of keyboard methods so you can spend less time looking for the right method and more time building your automation. We took over 40 low-code methods and combined them into just 2 easy-to-understand options (with all the same capabilities), so working with keyboard actions is even easier than before.
In some robotic processes, you may want to pause after submitting a form to allow the application to process the request. Or you'll want to take a screenshot before moving on to the next page. In this release, every low-code method supports these two options directly using the new After Completion options. You no longer need to add another action to your workflow, saving development time and making your workflow a bit simpler.
The features listed below are deprecated and will be removed in a future release of Appian. Do not begin using deprecated features, and transition away from any prior usage of now deprecated features. Where applicable, supported alternatives are described for each deprecation.
Appian sites created prior to our 20.3 release came with the Nexus repository for storing Java code. Appian now has its own code repository to store Java code, which is much easier for developers to use. As of the 7.7 release, Appian RPA is deprecating the provided Nexus repository. If robots are relying on this repository, follow the steps to migrate your code from Nexus to the console repo.
Instead of the
File type, designers should use the
Document type (added in version 7.6). Appian Documents are better for memory usage within Appian RPA and they integrate better with your applications.
Now you can set the execution priority when launching robotic processes from an Appian interface or process model. We give you the flexibility to set a fixed priority for a given process or vary the priority dynamically for individual instances. Effective prioritization optimizes your robotic workforce and ensures that your urgent automations are completed in a timely manner.
You can now define the number of times a robotic process execution is retried before the node proceeds with the failed result. This simple configuration in the Execute Robotic Process smart service means you don't need to build custom retry flows, simplifying your process model designs while making your automations more resilient.
Manage Appian RPA exceptions faster and more efficiently in this release of RWM. With new bulk resubmission capabilities and new filtering options, it's easier than ever for you to identify, select, and triage groups of exceptions. Then you can reassign, update, close, or re-trigger failed process executions in bulk. This capability makes it even more efficient to manage your RPA practice.
We've improved RWM's ability to sync higher volumes of data from Appian RPA. The Appian RPA REST API functions are now updated with better performance and data paging. RWM can handle significantly larger volumes of data within a narrow timespan, pulling data based on paged batches.
We are expanding Appian’s built-in document extraction features.
In our previous release, we introduced built-in extraction of key-value pairs for digitized, searchable PDFs. In 21.2 we’ve added extraction support for scanned documents through the use of out-of-the-box optical character recognition (OCR) technology. You can now automate the extraction of text values from digital and scanned documents alike, without using an outside vendor. We've enjoyed using it to support document processing internally at Appian, and look forward to hearing how you use it. Let us know at firstname.lastname@example.org.
As always, we continue to support automated extraction from a wide range of documents, whether you choose Google's Document AI service or the built-in convenience of Appian.
You'll now see better extraction results when using Google's document extraction services thanks to recent improvements in their services and our added support for v1beta3 form parser. In fact, we have seen dramatic improvements in handwriting recognition.
We'll continue to provide support for the latest document processing services so you'll get quick access to even more improvements and capabilities.
With every release, we aim to make document extraction easier and faster. The new table selection tool allows users to extract tables from their documents, even if the table was not automatically identified. Simply highlight the table values you want anywhere on the page.
The new streamlined way of getting information out of your documents reduces manual effort and works for both Appian and Google. This means cheaper and faster document processing and reduced risk of manual keying mistakes.
Many customers deal with high volumes of documents that need to be processed and extracted, and don't want to incur the employee cost of reconciling and checking over every individual document. With this release, you can now customize which fields must appear in a document type for it to bypass this manual reconciliation step. Now a few employees can process thousands (rather than dozens or hundreds) of documents.
To ensure your data's fidelity, this feature uses human-in-the-loop manual review for documents with data that is particularly difficult to extract. Alternatively, if you'd like to use more complex logic for determining which documents bypass manual reconciliation, you can also use custom expressions in Appian.
Get the most out of IDP's document extraction capabilities with Google's new and improved Google Beta v3 extraction algorithm. In Appian 21.2, the document extraction smart service can use Google Beta v3, which uses a processor Id generated by Google. You can try this now directly through IDP.
As impressive as our new low-code data features are, they're not the end of the story. This release includes a wealth of low-code features that make building your applications faster and easier.
We’ve heard your request to improve the ability to match corporate style guides within Appian. With this release, we’re giving you three important ways to match your branding: dark color schemes, custom background colors, and rounded components.
In 20.3, we added the ability to configure a white or transparent background color on your interfaces by using header content layout. This release, we’ve added dark color schemes as options to easily create dark-themed designs. The examples below showcase the new Charcoal, Navy, and Plum color schemes. These can be used for interfaces, cards, and Site branding. When used together, your site pages will achieve a cohesive, visually pleasing look. Check out dark color schemes to get started.
If your corporate branding style guidelines require you to use a specific background color, you can now specify any valid hex color code on header content layout. Not only does this allow more branding flexibility, it furthers the capability to quickly create beautiful interfaces.
You can now set rounding for a variety of components using an easy one-click setting in your site branding configurations. This complements the existing capability for rounded buttons and provides a low-code way to create modern looking applications.
In addition to general component rounding through site branding configurations, we’ve also added the ability to configure rounding on individual cards and boxes to provide you with greater flexibility. You can now set your cards or boxes to be squared, semi-rounded, or rounded. Use these new styles to better match your corporate branding and style guides.
We’re giving you more power and flexibility to create user interfaces (UIs) that your users will love. This release introduces interfaces as site pages, automatic scrolling for wizards, powerful section enhancements, loading indicators on buttons, improved mobile grids, and more.
Creating a site just got easier. When adding your page in a site, you can now directly use an interface as a site page. Not only will this reduce the number of objects in your application, you can get your site up and running even more quickly.
Forms and wizards will now automatically scroll to the top of the form when navigating between pages of the form across all of your devices. This removes the need for users to manually scroll back up after navigating between steps and prevents them from missing important information. Also, in these situations, the focus will return to the top of the page, improving the experience for users who navigate with a keyboard or utilize a screen reader. The best part about this enhancement is that it automatically applies to all of your forms without any additional development.
Section labels are more flexible than ever. Increased customizability includes the ability to choose from a variety of sizes, icons, and predefined or custom colors to add to your section labels to create even more beautiful UIs. Additionally, you can now set the heading level tag for section labels to ensure your interfaces comply with accessibility standards.
Section divider lines now have color configurability and three new widths to choose from. Use divider lines with these new configurations to delineate content in dense interfaces in a visually aesthetic way.
You can now nest sections within sections to better organize information in your interfaces. With this new functionality, it is now easier than ever to reuse sections throughout your applications. Use the new nesting functionality to create more content-rich, reusable interfaces.
Do you need a way to inform users that a form submission or request is processing? You can now set the button component to disable upon click and display an animated loading indicator to more clearly signal to users that loading is occurring. This new configuration is perfect for mitigating users from double-clicking buttons or refreshing the page, offering an improved usability experience for submissions that may have longer processing times.
On rich text display fields, you can now specify a tooltip which displays on mouse hover or keypress. This new parameter is particularly helpful when you want to give additional context about what’s displayed to your customers. Use the tooltip parameter to create even more informative and dense interfaces.
In 21.1, we introduced a preventWrapping parameter on rich text display field which truncates content to a single line to improve responsive behavior. This release, we’ve enhanced the behavior to automatically show a tooltip with the full text on hover when the text is truncated. You can use this parameter to improve the look of your interfaces on narrow screens while retaining an easy user experience.
Choose any color for your milestone components. Select a hex value or use one of the predefined colors to get started. This enhancement makes it easier to have consistent color palettes across components.
We’re committed to providing helpful examples for you to work with every release. Check out our new Admissions Dashboard template, Duration Display pattern, and Dynamic Inputs pattern in Interface Designer to get inspiration for your next interface.
a!update() function provides an easy way to update values of lists, maps, records, dictionaries, and CDTs in your expressions. This function will simplify your expression, make it easier to manipulate data, and be more robust to changes to your data structures. Visit the a!update() function page for examples on how to take advantage of this function's capabilities in your applications.
The new a!defaultValue() function allows you to check for null values or empty strings in your data and specify a backup value if that is the case. This function will simplify your expressions since you no longer need to use nested
if() statements to achieve the same behavior.
With groups, you can build flexible visibility logic into record types, sites, interfaces, and more. In this release, we’ve updated the a!isUserMemberOfGroup() function to support checking a user’s membership in one or more groups at the same time. Now it’s even easier to target your application information and actions to the right people.
With our real-time design guidance, low-code developers receive live, actionable feedback on best practices so they can build even more quickly and confidently. Team leads will also love the visibility provided by the Health Dashboard, which surfaces all of the design guidance from your application or the environment.
Expression design guidance is now available in additional object types. Records, integrations, sites, and decisions now support guidance in all expression editors. Catch risky design patterns before they become problems and ensure your expressions are easy to maintain. As with all guidance, recommendations and warnings for these additional object types also appear on the Health Dashboard.
We’ve given design guidance a fresh new look and added more expression warnings and recommendations. Appian now warns you about variables or rules that are missing a domain prefix. Using domains is a best practice to ensure your expression will behave as expected at runtime. Additionally, we’ll alert you about any unused local variables, which may be performing queries or passing data between objects unnecessarily. See expression design guidance for more information.
We’ve updated a few recommendation thresholds to match the Design Review Checklist, so guidance is more consistent and easier to learn.
The three recommendations with new thresholds are:
Expressions that are small and modular are easier to understand and maintain. With this release, we've added a new action to the expression editor toolbar to help you follow this best practice. Now you can quickly select part of your expression and easily move it into a new interface or expression rule as you build or refactor your application.
When you create documents like templates, images, or user guides in Appian Designer, it’s a common next step to create a constant so you can reference them in expressions. To speed up your development, Appian now automatically creates these constants for you by default. To opt out, simply uncheck the option during document creation.
Object comparisons are extremely useful during peer reviews and troubleshooting. You’ve long been able to review the changes to your document metadata. New with this release, version comparisons also detect and highlight the differences in the contents of image and text-based documents. You can now understand changes made between versions of your documents at a glance.
We've heard from developers how helpful it is to be able to set security when creating objects from the New menu, so we added the same great experience to the create data type from database table or view flow. Now Appian will remind you to set security for any data stores created as part of this process to help ensure the right people have access to your data.
Easily scan expressions in site and record type grids in new read-only expression editors. This improved user experience provides proper formatting, syntax highlighting, and quick navigation to referenced rules without having to open the edit dialog. Additionally, all design guidance is immediately apparent so you can effortlessly find and address it.
Common pages in Appian Designer now have their own specific URL. When navigating to a folder, group, or package view within an application, you can right-click to open it in a new tab, bookmark your specific location, or use the browser Back and Forward buttons to navigate. The URL is also shorter and handy to share with a teammate, as it will direct them to the specific view in the same application you were looking at.
For the first time, you can authorize calls to Appian web APIs using the OAuth 2.0 client credentials grant. OAuth 2.0 is the industry-standard protocol for authorization. Like API keys, OAuth 2.0 clients are tied to service accounts. Since Appian acts as both the authorization server and the resource server, you won’t need any third party tools to take advantage of this new functionality. Simply navigate to the Admin Console to generate your credentials and you’re ready to integrate.
Web APIs have also been enhanced to support the PATCH method. This allows for greater flexibility when designing web APIs, enabling developers to adhere to API standards that leverage the PATCH method for their operations.
Trigger deployments programmatically with our suite of native deployment APIs, which can be called from an external orchestration tool such as Jenkins or Azure DevOps. Teams can easily integrate their Appian releases with existing automated pipelines, allowing them to coordinate with other software releases and business processes. With the APIs, you can set up your pipeline once and run it the exact same way for all future deployments, saving time and avoiding manual errors. You can also configure a post-deployment process to run after an API deployment completes, to further tailor your pipeline.
Developers can provide object packages, database scripts, and an import customization file to either inspect or deploy. The ability to use these APIs for a given environment is configured in the Administration Console.
You can now use compare and deploy to push deployments that contain only database scripts and/or plug-ins. This flexibility allows you to deploy more targeted changes, such as updating a database’s stored procedure or upgrading a plug-in, further streamlining your deployment process.
Since 20.3, developers have been able to review plug-ins and their usage in Appian Designer using precedent and dependent tracing. Now, you can view a plug-ins tab specifically for your application or package.
With this new filtered list, you can easily audit and refactor plug-in references within your application. It also provides early insight into plug-in dependencies that might need to be included in your next deployment.
With collaborative packages, teams can link object changes back to requirements, and effectively work together during development and peer reviews. Starting in 21.2, developers can easily combine contents from multiple packages to prepare a single release package. By creating a release package, you can ensure that all changes are deployed to higher environments in one go, saving time and simplifying your deployment process.
We're continuing to improve developer collaboration throughout the application development lifecycle. With the ability to share package links, you can now collaborate more effectively within your teams during peer reviews. Starting this release, Appian will also remember your most recently modified package everywhere you use packages - from development to deployment.
For auditing purposes, it can be important to trace deployed changes back to the corresponding requirements. The deployment details view now displays the ticket associated with your package. This allows you to quickly get to more details from your project management tool.
You can now configure actions on a site page for your mobile users to use offline. Offline actions allow mobile users to start processes in Appian even in the absence of any network connectivity and queue them for automatic submission when their devices regain a connection.
Learn more about Designing for Offline Mobile.
Build once, deploy anywhere. With mobile becoming increasingly popular among customers, we’ve highlighted the “deploy anywhere” concept by improving the read-only grid component to have more consistent behavior across web and mobile platforms. To achieve this, enhancements include “smarter” mobile grid behavior, such as column widths better fitting the content inside.
With this release, more of your interfaces and expressions will automatically run faster. Appian now runs more of your expressions in parallel where it helps the most, including within looping functions like a!forEach() and the rows of a read-only grid component. You'll notice the improvement more with reports or records that contain a lot of queries.
We're making Appian work better for you, so that you can continue to build rich, detailed reports and records while leaving the performance considerations to us. To learn more about how Appian runs queries in parallel for interfaces and expressions, check out the details here.
The Advanced Encryption Standard (AES) is a specification for data encryption. Using a 256-bit key and 14 rounds of encryption, AES-256 is its most secure variant. Starting in 21.2, newly entered credentials for connected systems, integrations, third-party credentials, and the health check will all use AES-256 encryption, making integration with Appian even more secure.
In phpMyAdmin, you can now clearly identify whether you are in your production, testing, or development environment. The phpMyAdmin user interface will display a colored header and label for each environment type. This eliminates confusion and accidental database updates when you have multiple windows open. For more information, visit Appian Cloud Web Administration page.
In an effort to ensure that emails are delivered in a timely manner, servers in Appian Cloud will have email throttling enabled.
This means that after servers have sent out a certain amount of messages, our mail server will not send out anymore emails for that particular server. The threshold is configurable, and the limit will be set at a level where normal operations will continue unimpeded.
Furthermore, depending on the disk space available on the server, the email will be buffered in case the emails need to be processed and sent out.
You now have the ability to use our Log Streaming feature with a syslog receiver hosted in the demilitarized zone (DMZ) within your network. This service will be configured with one-way Transport Layer Security (TLS) instead of AWS PrivateLink or a traditional IPsec VPN tunnel.
For customers using their own domain to host their Appian Cloud sites, Self Service Certificate Management allows you to take a look at the certificates hosting your Appian Cloud environments within MyAppian.
You can quickly see:
The isusermemberofgroup() function has been evolved in this release. The new version allows checking membership against multiple groups at the same time.
The ability to import an individual process model has been removed from the File menu in the process modeler. Instead, deploy process models as part of an application or package.
On This Page