Amazon Echo Look

Amazon launched the $200 Echo Look today. The Big Brother privacy concerns will be discussed ad nauseum, so I’m going to avoid discussing them here.

An outfit suggestion product may sound silly,  but I think it’s simply Amazon’s first step to get a photo/video sensor into consumer homes, which could have amazing applications. The first Echo brought the microphone into the home; Echo Look will bring the rest. Security was the first killer app for the home photo/video sensor, but outfit suggestion is non-threatening, friendly, and fun. It’s a stepping stone.

Here’s an optimist’s view of the potential of the home video sensor:

  • You walk into your front door and the lights come on, your speaker system starts playing your favorite jazz station, and Colbert appears on your TV.
  • You’re out of detergent, so you hold up the Tide container to the camera and ask to order more. It shows up the next day.
  • You point across the room and say “turn off that light” to turn off a specific lamp.
  • You ask “where’s my iPhone” and Echo Look tells you where it last saw the device.
  • The device knows what you eat, when you sleep, who visits you, and all your daily habits. Alexa becomes Her.

These ideas are only scratching the surface, but it seems to start with outfit suggestion functionality today.

Thoughts on Appian 16.3

Despite dropping a little later than usual this year, Appian 16.3 was released earlier this month and brought a ton of exciting new features across all aspects of the product. Apparently the release was delayed due to extensively testing Appian’s new High Availability cloud offering, but no matter, let’s dig into the new features!

End Users

Sites Improvements

Sites continues to quickly improve and move towards being the default view for most small applications. 16.3 brought the addition of regular Reports to the interface. Previously, only Task Reports were supported which required some hack-y workarounds.

Tasks and all records now render in Sites as well, so there’s no reason to go back to the “5 tabs” environment, except for maybe the Feed. User records can be included in Sites as well now, which helps for kicking off user-centric related actions.


Tasks now take up the full width of the screen, and the left column has been moved to the top bar. The increased space is great, especially for grids with lots of columns, and hints at the upcoming Modern UI improvements like the three column layout.

Also, Task emails can now be turned off at the task-level. This is a welcomed improvement mostly because Appian task notifications are generally horrendous. The email template is poorly designed, is not responsive to mobile, there’s no (easy) ability to customize, the task information available is severely limited, and the recipient doesn’t know whether the task has been completed or not. Turning the emails off is one way to solve the problem. But outgoing email management could use a major refresh given how often it’s used in the product.


Hierarchy Browser Tree

A couple years ago, Appian really struggled showing nodes, graphs, or hierarchical data. You could kind of use grids or multiple components but the experience was always clunky for the end user. It’s gotten much better with the Column Browser component, but the newly released tree component looks great. I’m excited to try it out.

User Card on User Record Links

User cards now popup over a User record link. It provides a nice display with context about the underlying user, but this feature just reinforces that you need to actively get your users to update their profiles. Sadly, I see a ton of Appian environments with very few profile pictures and background pictures. Bringing in these pictures automatically is a great way to increase engagement from what I’ve seen.



With 16.3, the “still in beta” cross browser Process Modeler has gone from “good enough” to “good”. The new modeler is starting to get features not available in the legacy version like multi-selecting of nodes and resizing the window. I’m sure it’ll continue to get better and better in future releases.

The Application Designer continues to improve as well, adding functionality to pre-populate object names and ‘Save Into’ folders. And process models are now updated automatically with new versions of a CDT. These improvements all lower development time and increase productivity.

Multi-sort is now available on a!queryEntity(). I’m a little surprised this feature took so long since I believe multi-sort has been available on query rules for some time now.

Quick Apps

Quick Apps got some updates. You can find the details here. The updates are fine.

But seriously, Quick Apps is pretty good for creating a quick demo, a PoC, or possibly to bootstrap an application for a new Appian Designer. Small CRUD applications could be a good fit as well, but a solid wiki, hosted spreadsheet like Airtable or Google Sheets, or MS Access database might be the better tool for the job. But I believe Quick Apps still has potential if simple approval tasks and small workflows are added in a future release.


Admin Console settings can now be imported and exported to easily transport across environments and you can define environment-specific configs as well. The Admin Console keeps getting upgraded so that sys admins can stop messing around with text files on the server. In performance news, process archival has been moved to the app server, which should free up bandwidth on the Execution engines.

Appian is starting to offer a Hot/Hot high availability cloud environment, which could be used for mission critical applications in the cloud. The more customers choosing cloud over on-prem, the easier their lives will be, and the better Appian looks to investors. 🙂

Deprecations (Cleaning house)

Out with the old and in with the new!

Prior to about 2011-2012, Appian’s main end user interface was its Application Portal, which focused mainly on process dashboards and process reports. It included a less-than-appealing pre-“Enterprise Web 2.0” UI, required hacking together JSPs and HTML snippets, and included some odd and distracting styling bugs. But over time, Appian built out the Tempo interface, first around the social feed and expanding to the “5 tabs” layout, and then added native mobile clients, Sites, and Embedded interfaces more recently, all based on their SAIL technology. Next year brings a fresh new look, called Modern UI, that continues to keep up with end user’s need for a pleasant user experience to match their excellently designed consumer applications.

So, time to get rid of the legacy objects and interfaces since they can be confusing for new Appian Designers and unnecessarily increase the ramp up time for developing applications. Here’s a little of what’s getting deprecated:

  • Application Portal – If you’ve used it, you will probably say “good riddance”.
  • Process Report Charts & Indicators – These were fairly nice pre-configured charts during the Application Portal days. RIP.
  • Forms Designer – I spent many hours learning the ins and outs of this tool. The drag and drop features were way before their time, but there were some infuriating bugs and overly complex configurations that make writing SAIL feel like a walk in the park on a nice fall day.
  • Communities – Further refinement of Appian’s content management system. Now it’s mostly Knowledge Centers and folders.
  • Attachments and Notes on Process Models – Never used and supremely confusing to new Appian Designers. Should have been hidden/removed years ago.
  • System Groups: Document Administrators, Portal Administrators, Tempo Global Message Authors – More unnecessary complexity that was rarely used.
  • Smart Services: Send Alert, and lots of other Portal services – ‘Send Alert’ sounds like a good idea, but the email notifications were always so terrible. ‘Send Email’ is pretty much always used instead, with a custom html template of course.

Some older customers will probably be a little irritated about being forced to upgrade their UIs. I know some customers with major mission critical applications still running on these older designs. Luckily, Appian has agreed to support the Application Portal through October 2018 so there’s plenty of time to upgrade.

16.3 is the last release of the year, so we’re done for 2016! Next year will bring plenty of excitement for the Appian community including an updated Modern UI, Appian World in San Francisco, and more rumors of an IPO!

Until then, if you ever want to discuss anything Appian, automation, or just tech in general, you can find me @corbpage. Let’s connect!


Appian 16.2 Review

Great seeing everyone at Appian World this year! It’s always a blast catching up with old friends, past clients, and talking shop about the latest techniques with Appian. My personal favorite had to be the Appian integration with Amazon Alexa, but Baxter came pretty close! I can’t wait for the day when clients start requesting those types of integrations!

Appian always releases a large feature-packed upgrade ahead of the conference, and 16.2 lived up to the hype! As always, I’ll be presenting my strongly opinionated overview of the release below, highlighting the most impactful features, how I believe they’ll be used, and what they say about Appian’s product roadmap.

We’ve got a lot of ground to cover, so let’s started!


I’m incredibly impressed with how Sites has evolved over the past couple releases, and 16.2 added the ability to embed Record lists along with Reports and Actions. I love the balance between simplicity and controlled customization that Sites now provide with custom branding and font awesome icons, and I’d strongly recommend using Sites instead of the Tempo interface when introducing an MVP or 1st app into an organization.

At this pace, I think Sites will be the primary interface for the majority of Appian apps 1-2 years from now. Right now, the interface is still constrained by only allowing 5 tabs though. Workarounds exist of course, but I’d love to see Appian introduce dropdown menus or some other intuitive way to navigate to more information.

Coincidentally, the Tempo interface suffers when too much information is available, and I’ve seen clients with 20+ Actions or 40+ Reports that are incredibly difficult to navigate since there are no options for grouping them and minimal filters available. Appian still hasn’t cracked this nut. The environment should feel simple yet robust when a client is starting out with 1-2 apps (close to what Sites is now) and scale to an easily navigable, dynamic command center for an organization as the platform model takes off. Universal search would be a good starting point for the latter example.

Quick Apps

Appian was pushing Quick Apps pretty darn hard at Appian World, but I’m still a bit skeptical of approach. Quick Apps is basically a wizard walkthrough to simplify and speed up the creation of super simple applications. Geared toward business users, Quick Apps creates a ton of Appian objects to do basic CRUD operations on a record, with a fairly pleasing UI, and a couple other bells and whistles.

Here are my initial thoughts:

  • It’s a great tool for demos, Business Analyst-use, and possibly bootstrapping a first application. It automates the construction of commonly used aspects of an application like the record dashboard, basic editing of data, etc.
  • But I don’t recommend using Quick Apps in Production. Aside from the worries about accidentally creating a malicious application or memory hog, I believe end-users creating TONS of apps in Prod without them being considered, vetted, and tested by IT is messy and shortsighted.
  • Generators are used in web frameworks all the time (Ruby on Rails especially), and there’s always a balance between “stand up something quickly” and “now I need to customize”. Unfortunately, enterprise software almost always falls towards the latter for any serious application:
    • Sensitive information is being used, so permissions need to be finely tuned among stakeholders.
    • DBAs want complete control and approval over the schema.
    • Best Practices or a coding style guide is strictly enforced.
  • From a first pass through the code generated by Quick Apps, I haven’t loved what I’ve seen:
    • Appian’s Standard Object Names don’t appear to be followed in all cases. I saw constants that weren’t all uppercase and variables that weren’t camel-case. Mismatched naming conventions and coding styles hinder maintainability and lengthen developer ramp up times.
    • Some undocumented/private uses of expressions (mainly if()) have turned up in some generated code.
    • Each Quick App generates TONS of Appian objects, but common rules like ‘displayUser’ are then duplicated for each subsequent quick app. Sounds like another a maintenance nightmare.
  • Each app has an “Activity History” which will be duplicated across apps and feels like a feature that should be built into the base product, not simply generated via Quick Apps or built by

New Components

Inline Rich Text Images

Inline images/icons are a great way to make a Record or Report stand out and are particularly effective at displaying categorical data to users (statuses/priority/performance). When the user first sees the field, they can read the text, but over time, a quick glance at the icon color/shape tells them everything they need to know. This UI paradagm is particularly useful in grids where users are scanning down a column. I plan to opt for inline icons over simple text quite frequently.

Hierarchy Browser Component

This new component allows end-users to better navigate any tree-like data structure, which Appian has traditionally struggled with. Previously, a designer had to use some combination of grids and links to build out a clunky solution that they would have to train end-users to operate. I’d recommend keeping this component in mind for selecting tree-like or parent-child structures over a grid, custom picker, etc.

For Designers

Execute Smart Services in SAIL/Web APIs

Definitely the biggest paradigm shift for designers in 16.2, most Smart Services can now be executed from SAIL, instead of just processes. There were a couple plug-ins that have provided a similar effect in the past, but this is a huge shift for OOTB development. For instance:

  • The a!writeToDataStoreEntity() function can be used edit scalar or grid data instantaneously, instead of on form submission. Reports can be used to edit data dynamically without needing to kick off a process.
  • The a!startProcess() function could be used to start asynchronous processes directly from an interface, instead of via process model routing.
  • Functions like a!completeTask() and a!cancelProcess() can be used in interfaces where end-users administer or cancel active tasks/processes.
  • Web APIs are now “writeable” since they can call a!writeToDataStoreEntity(), and developers can now RESTfully start a process via a!startProcess().

I am curious about how error handling works, if say a database insert fails or a user doesn’t have permission to change a document, but can’t wait to see all the interesting use cases and design decisions that these new expressions will spur. Previously, Appian expressions guaranteed that they wouldn’t have side effects but that seems to have changed. There’s a good chance that applications will soon be labeled as pre-16.2 and post-16.2 because of the large deviation in how they’re built.

Cross-Browser Process Modeler (Preview Edition)

Designers can now use the process modeler from any browser, SAIL forms are available from debug mode, and the process modeler has a slick new look. I appreciate these improvements immensely, mostly so I can develop from my Mac via Chrome without painful workarounds. Kudos to Appian for releasing this feature in preview mode, rather than holding out til all the functionality is present.

My only hesitance is that the re-skinning of the process modeler misses an opportunity to improve and simplify the process modeling experience and reduce the ramp up time for new users to learn the interface. I’ll probably touch on this in a future post, but there’s ample opportunity for streamlining the experience (node inputs vs. outputs, multi-select nodes, number of nodes to learn, etc.).

Data Type Updates

  • Data types are now updated on import without deleting the old version. This improvement will help remove an extra deployment step that’s commonly needed.
  • Appian objects that reference the data type are now updated automatically, except for process models. Another improvement to simplify deployments and make Appian designer’s lives easier.


Testing Appian applications has come a long way in the past couple years. 16.2 continued the trend with some useful new features, and, in addition, the Appian CoE recently released an automated testing suite for Appian built with FitNesse and the excellent Selenium web driver.

  • Complete Task & Start Process Smart Services – These new Smart Services replace the popular Task Puppeteer plug-in and can be used together to automate the user tasks of a process to run tests or “fast forward”.
  • Batch Testing of Expression Rules via Smart Services – Expression rules can be tested in bulk at the application level or via process model.
  • FitNesse – I’ll do a deep dive into the FitNesse automated testing suite in a future post, but I’m super happy to see Appian getting behind a particular automated testing approach. I’ve seen clients build their own version, but they were always worried their css selectors or xpath would breakdown with every Appian release. I’m excited to play around with the Fitness tool and answer the question: is Appian finally ready for behavior-driven development?

Best of the Rest

  • Tempo is 25% wider – Screen real estate is always important and widely varied these days. I’m glad Appian is now more responsive to wide screen displays.
  • Good for iOS – Appian is now compatible with Blackberry’s Good technology for iOS. Good is really popular in enterprises so glad to see the support.
  • folder() – File this improvement under **FINALLY**! The folder() function now supports “documentChildren” and “folderChildren” properties, so the Custom Content Functions plug-in isn’t necessary for basic document retrieval.
  • For Admins
    • Import/Export configurations from the Admin Console
    • User Management via the Admin console including bulk actions
    • Application Import history is now available in the Admin Console

Whew, that was long! And I didn’t even cover everything! Too many features and too little time!

I’d love to hear what you think of Appian 16.2 and my review!

Drop me a line at or @corbpage and let’s discuss!