Tag: ServiceNow

How ServiceNow’s ‘Virtual Agent’ can assist your organisation: Part 1

 

This blog entry is part of a four-part blog series on how ServiceNow’s Virtual Agent can assist your organisation.

 

If you talk to someone about the present state of the IT industry, artificial intelligence, virtual agent and chatbots are topics that commonly surface in one way or another.

From forcibly having to “deal” with it while trying to raise a support query from your internet provider to something less prominent to having a popup in the bottom right part of your screen asking if there is anything they can help with.  These concepts have become front and centre in the drive to provide a better customer experience to users.

They are often get implemented with the best intentions, but when not implemented with the right strategy can turn a previously acceptable user experience, to a frustrating one where you are constantly getting distracted by notifications.

  • Is implementing a virtual agent the right thing to do?
  • Will it really provide a better experience for users?
  • Will it improve satisfaction for all members of my organisation and my customers?

In a word, yes.  This blog series will discuss four main topics that should be front and centre when talking and thinking about virtual agents for your organisation, as well as some small bits of wisdom to take on your journey.

We at JDS Australia would love to help you on this journey, and fortunately ServiceNow has a great Virtual Agent out of the box that you can utilise.

Part 1: Empowering People

When Virtual Agent comes up in conversation, the concept of empowerment comes up but normally only focusing on the end user.

In reality though, Virtual Agents help empower both sides of the coin.

What does this mean though?

How can virtual agents empower both end users, service agents and the organisation and their customers at large?

The End Users

To start, let’s start with a thought experiment.

You and everyone else reading this article is an end user somewhere.  Whether for your internet service provider, mobile provider or even as a patron of your favourite fast food chain, you have experience as an end user and will have seen an evolution in how this is done.  In your head, what do you consider a good experience? What do you consider a negative one?  What do you think would help that experience?  Fast food chains introduced self-service terminals where you can order without talking to someone and various telecommunication organisations introduced Virtual Agents, both with varying levels of success.   Now think about the place that you work or the customers that you serve.  What is something you answer day in, and day out based on a question that is commonly asked?

Frankly speaking, Virtual Agents have a bad habit of being introduced and forced onto users, whereas really it can be introduced to empower users, by offering them options and saving time.  If we investigate the last question in our thought experiment, the joke answer is “have you turned it on and off again”. It may be seen as a joke, but yes, it sometimes helps (despite our reluctance to do it before calling).

In a more complex example, what about access and permissions to an external system?  The most common response is to call up IT or ask your friendly IT support team to do it off the record, but what happens if you could do it yourself?

Various systems and applications offer a range of web services that you can hook into with ServiceNow via an integration.  Through these integrations and details you may find on a user record, you could simply automate it.  Where does Virtual Agent play into this though?  Before getting access to a system or understanding permissions, there are often a variety of questions based on the application you are speaking about.  The Virtual Agent can ask these questions first and respond based on the answers provided.  It may not necessarily remove all human interaction to make the request possible (such as requiring approvals), but it will handle the questions that need to be asked that may cancel a request before it is even raised.  Saving the time of the end user, as they no longer need to make time for a phone call and saving the time of the service agent, as they no longer have to spend the time to have the conversation, which includes the time to get back into the groove of what they were working on.  This gives the end user the feeling as they solved their own issue and provides them with the confidence to try to solve this issue first without calling the help desk.

What does this mean for the service desk agent though?  If they are not on the phone with end users, how does this empower them?  Doesn’t that make their job redundant?

The Service Agents

In a word, no.

In fact, having the various service agents involved to in the investigation of how they can better serve the end users is more important than ever.  These are the people who now can spend more time on more complex questions and fulfilling the manual requests when needed and know what is best when serving the end user.  The Virtual Agent empowers these users even more than the end users, as now they can be involved in the development and continual improvement of the Virtual Agent.  This provides the service agents the power to be directly involved in the improvement of their services to the end users but using their experience to ask the questions they need to, to get a better outcome.

That is the main opportunity for Virtual Agent when the service desk agent is directly involved.  They can help in improving the questions and topics that a Virtual Agent asks the end user, so they get the information that they need to resolve the query first time as they continually improve it.  That is what is important to note and the reason why service agents do not simply become redundant.  Implementing a Virtual Agent is not a one and done, it’s a continual process to ensure that as your understanding of your newly empowered end users improves, so the mean time to resolve tickets improves.  Up to the point that this no longer even becomes a metric for some requests, as through asking the correct questions, these issues can be resolved without even contacting the service desk.  This is a concept known as contact-less resolution and will be spoken about in more depth in the next part of this blog series.

So if the end users now feel empowered, as they are now able to solve more issues in their own time, out of hours and without picking up their phone and service agents now can focus on improving these experiences and can spend more time on more complex tasks, what does this mean for the organisation as a whole?

The Organisation

The organisation itself also is empowered as a result of this.  People now feel a sense of autonomy as they are not necessarily required to spend their work hours doing what they use to, as the Virtual Agent assists in alleviating some of the needs around this. The organisation can bring forth new initiatives to improve their service further.  The organisation can direct users down the path they need them too to achieve their goals… but the change on the organisational level is not so much about empowerment, but how the operational insights can move your organisation forward.  That topic however, will be discussed in a later part of our blog series.

What is the end goal when it comes to implementing a Virtual Agent?

How can this can be taken even further?

In the next part of this blog series, we'll cover contact-less resolution.

In the meantime, check out this great Virtual Agent demo from ServiceNow!

ServiceNow Upgrade Process

 

With ServiceNow committing to two major releases a year and only allowing customers to operate on n-1, having a well understood upgrade process is not a luxury, it’s a necessity.

To reduce the risk of disruption to the business during upgrades, JDS recommends organisations adopt a clearly defined strategy for upgrades.

  1. Prepare Environments
    • Back up any update sets in non-production
    • Clone production over non-production so the latest configuration and data is available for accurate testing. The clone should include the audit history and the system logs.
    • Upgrade non-production to the latest version of ServiceNow
    • If necessary, reapply update sets, although the recommendation is to suspend custom development during the upgrade process
  2. Bottom-Up Analysis—Review of the upgrade logs:
    • Review skipped updates to understand any potential impact on the upgrade. Although the focus is on skipped records from the latest upgrade, it is important to understand previous skipped records as there may be dependencies that cause complications
    • Focus upgrade testing on areas where updates have been skipped to ensure there are no adverse effects
    • Provide recommendations on where skipped records should be restored or merged to future-proof the organisation
  3. Top-Down Testing—Upgrade testing
    • End-to-end business process testing to ensure the veracity of the upgrade in non-production
      • Business involvement from SMEs (subject-matter experts) is critical to the success of upgrade testing
      • Where possible, follow previously established test cases
      • In the absence of established test cases, JDS recommends a random sample of records, following the audit history of each record and duplicating each step with a new test record (including impersonating users and replicating each of their updates)
      • Automated testing is intended to supplement manual testing
    • Integration testing
      • As much as possible, verify integration works as expected in non-production
      • Inbound email actions can be replicated by manually importing the relevant email XML record from production into non-prod and manually activating the “reprocess email” command
      • Outbound emails can be viewed in the email queue
  1. Defect identification and resolution
    • Based on the results of the previous steps, defects will be classified as
      1. Relating to the core system and therefore the responsibility of ServiceNow support
      2. Relating to the customised system and therefore the responsibility of the customer
        • Where possible, JDS will propose and implement defect resolution in consultation with the customer
        • If issues cannot be resolved, JDS will propose and implement a workaround
      3. User Acceptance Testing
        • UAT should not be confused with the upgrade testing. The bulk of end user testing should have already occurred under the upgrade testing phase. This particular UAT is intended to verify defect resolution.
        • UAT validates the issues exposed during the upgrade process have been rectified to the satisfaction of customer.
        • It is important to note that UAT need not be exhaustive as it's role is to confirm that defects exposed during upgrade testing were resolved
          • Additional defect resolution may be required if additional issues are exposed.
  1. Go Live
    • Upgrade production environment
    • Apply update sets based on the defect identification and resolution
    • Clone back to non-production environments to ensure all environments are in sync and on the latest version of ServiceNow
  2. Go Live Support
    • JDS recommends a go-live support for a period of two weeks
      • Any issues raised during the go-live warranty period will be subject to development and testing in non-prod and will require change management approval before deployment in production
      • If no issues arise, there’s time for enacting best practices and enhancements

The focus of upgrade testing is risk mitigation. The amount of time and effort spent on each of these phases will differ from one customer to the next depending on the size and complexity of their ServiceNow instance, along with the criticality of ServiceNow to their business practices.

If you want to learn more about upgrading ServiceNow, talk to JDS.

Modifying Service Portal Widgets On-The-Fly

 

Recently, a customer asked us to remove their Get Help catalog item from the list of Popular Items in the Service Portal because it's not really an item (it's a record producer) and it's accessed from the home page as well as being in the menu bar so it doesn't really belong under Popular Items.

The challenge was, how could this be done WITHOUT changing/modifying the widget (to avoid skipped upgrade updates)

Previously, I've written about how to manipulate portal widgets without modifying them, but that was on submission. This required modifying the widget on load, dynamically changing its contents on-the-fly without actually altering the core widget itself. The trick is to embed the OOB widget and use angular to inject the change.

As you'll see, the code is simple and yet effective, and could be repurposed for a number of other similar applications. Our custom widget acts as a wrapper around the OOB widget (which in this case is sc-category)

Widget HTML Code

<div>
   <sp-widget widget="data.remoteControlWidget"></sp-widget>
</div>

Widget Server Code

(function() {
        data.remoteControlWidget = $sp.getWidget("sc-category");
})();

Widget Client Controller Code

function($scope) {        

        var c = this;
        //We can get the angular data object of BOTH widgets
        var thisWidgetsData     = $scope.data;
        var theOtherWidgetsData = $scope.widget.data.remoteControlWidget.data;

        //Look at the remote scope.data object for sc category to see if have the item we want to hide/remove?
        theOtherWidgetsData.items.forEach(function(item, location){

               //Is our "Get Help" widget on the page?
               if(item.sys_id=='ea8accaedb0508103ea3cd051496198b'){

                       //Angular's injector invoke will allow us to change the scope within a digest
                       window.angular.element(document.body).injector().invoke(function($compile) {

                               //Now we can modify the other widgets scope and angular will do the rest
                               theOtherWidgetsData.items.splice(location,1);
                       });
               }
        })      
}

In essence, all we're doing is remotely accessing the OOB widget's angular scope and then using angular's injector to update that scope.

Although this might seem overly complex, we can look at the scope of any angular widget by holding down the Control key and right-clicking above the widget. Once we've identified what needs to change (in this case, removing an entry from an array), the rest is quite simple.

Have fun!

Custom Glide Modal Dialog Boxes in ServiceNow

 

Modal popups are an effective way of interacting with users when more information is required than would ordinarily be available on a screen. For example, confirming a deletion or getting more information when someone is submitting a record.

ServiceNow has a client-side API called GlideModal but the documentation is focused around displaying records or lists from ServiceNow rather than ad-hoc modal details. There are times when customers need a custom form with a few specific options.

In this example, we're going to add a UI Action button to the catalog task form so when a task is cancelled we can mark it as either:

  • Closed skipped - effectively cancelling the task
  • Closed incomplete - closing all related tasks along with the requested item itself

In this way, we're giving our users the ability to clearly determine what they're cancelling—just one particular task or the whole request.

UI Actions run code on both the client and the server, which is very handy.

The key to getting flexibility with glide modal dialogs is the renderWithContent function which allows us to craft our own HTML form and the window.whatever which allows us to intercept and interpret whatever happened on our modal window as the user interacted with the various options we gave them.

Consider the following code:

////////////////////////////////////////////////////////////////
//Client Side: Dialog box with choices
////////////////////////////////////////////////////////////////
function cancelDialog(){

   var gm = new GlideModal('cancelTask');
   //Sets the dialog title
   gm.setTitle('Cancel Task');
   //Set up valid custom HTML to be displayed
   gm.renderWithContent('<div style="padding:15px"><p>What action do you want to take?</p><p><select name="cancellation" id="taskCancellation" class="form-control"><option value="cancelOnly" role="option">Cancel this task but keep the requested item open</option><option value="cancelAll" role="option">Cancel this and all other tasks, closing the requested item</option></select></p><div style="padding:5px;float:right"><button style="padding:5px;margin-right:10px" onclick="window.changeTaskAction(this.innerHTML,jQuery(\'#taskCancellation\').val())" class="btn btn-default">Abort</button><button style="padding:5px" class="btn btn-primary" onclick="window.changeTaskAction(this.innerHTML,jQuery(\'#taskCancellation\').val())">Cancel Task</button></div></div>');

   //We'll use the windows object to ensure our code is accessible from the modal dialog
   window.changeTaskAction = function(thisButton, thisAction){

      //Close the glide modal dialog window
      gm.destroy();

      //Submit to the back-end
      if(thisButton=='Cancel Task'){
         if(thisAction=="cancelAll"){
            g_form.setValue('state',4);//Closed Incomplete -- will close the Requested Item and all other open tasks
         }else{
            g_form.setValue('state',7);//Closed Skipped -- will only close this task
         }
         //Regular ServiceNow form submission
         gsftSubmit(null, g_form.getFormElement(), 'cancel_sc_task');
      }
   };
   return false;//prevents the form from submitting when the dialog first load
}

////////////////////////////////////////////////////////////////
//Server Side: Dialog box with choices
////////////////////////////////////////////////////////////////
if (typeof window == 'undefined')
   updateTask();

function updateTask(){
   //Runs on the server
      if(current.state==7){
      //closed skipped so simply update this one record
      current.update();
   }else{
      //closed incomplete so update all associated records to close the requested item entirely
      current.update();

      //And now we'll cancel any other open tasks along with the requested item
      if(!gs.nil(current.parent)){
         //Close siblings
         var otherTasks = new GlideRecord('sc_task');
         otherTasks.addEncodedQuery('request_item='+current.request_item+'^stateIN-5,1,2');
         otherTasks.query();
         while(otherTasks.next()){
            otherTasks.state = '4';
            otherTasks.update();
         }
         //Close parent
         var ritm = new GlideRecord('sc_req_item');
         if(ritm.get(current.parent)){
            ritm.state = '4';
            ritm.stage = 'Cancelled';
            ritm.update();
         }
      }
   }
}

Our Glide Modal Dialog presents the user with two options in the browser and then executes the user’s preference on the server.

Code like this can be easily retrofitted, becoming a template for how ServiceNow interacts with users before records are saved. This code has been provided in an attachment. If for some reason the attached UI Action doesn't work for you, toggle the "isolate script" field (save it on then save it switched off) and it should run just fine.

Click here for a copy of the code: sys_ui_action Cancel Catalog Task

Happy coding.

Manipulating Service Portal Widgets Without Modifying Them

 

It’s common for organisations to want something a little bit more than what is on offer by ServiceNow in its service portal, but without breaking any core functionality. In this article, we’ll look at how you can manipulate an existing out-of-the-box widget WITHOUT modifying it.

One option is to clone the widget and change it but that causes your cloned version to become locked in time, so it won’t benefit from any enhancements or bug-fixes applied to the original widget by ServiceNow as versions upgrade.

A better approach is to embed the original widget INSIDE another widget and make your modifications there. In this way, you get the best of both worlds. Any changes to the widget will be automatically inherited, while you can change the behaviour of that widget at ease.

This article assumes you are confident in developing custom widgets. If you need more information on what service portal widgets are and how they work, please refer to:

Here’s how it can be done (with this code sample provided at the bottom of the article)

First, notice we’re using the sp-widget directive to embed an OOB widget, but we’re going to use an angular data object (essentially a variable) to hold the name of that widget. This gives us the flexibility to add HTML/Angular before and after the widget.

We populate this angular object in the server script. This gives us the ability to set any properties the widget might be expecting. In this case, we’re going to use the ServiceNow catalogue item widget (v2)

Now, in our client script, we can refer to data in BOTH our widget and the OOB widget, something that is extremely handy!

Finally, in this example, we’re interested to add some extra functionality when the original OOB widget is submitted. Looking at the client script for the OOB widget, we can see that ServiceNow are using broadcast events to transmit (emit) various actions. This is what we’ll intercept.

As you can see there are several events we could intercept and augment, like when a submission fails. Once we know what we’re looking for we can simply listen in the background, waiting for that event to occur.

Once that event fires, we can then choose to do something in addition to what the OOB widget is doing using both client and server code in our custom widget (and importantly, acting on information gathered by the OOB widget itself).

$scope.server.get allows us to send an action the server where it is processed and the response is returned.

In this way, we can manipulate an out-of-the-box widget provided by ServiceNow without modifying or cloning it.

Please find example XML here: sp_widget example

Virtual Agent Is Your Friend

Don’t underestimate the importance of user satisfaction

If there’s one defining characteristic of the social media revolution it’s “make life easy.”

Why did Facebook win out over MySpace? Facebook made it easy to connect, easy to post, easy to find people, easy to interact.

Amazon, Google, Twitter and Facebook have spent the last decade refining their technology to lower the barrier-to-entry for users, making their web applications highly accessible. Have you ever wondered why Google only shows the first ten entries for each search when it could show twenty, fifty or a hundred? Google found that 10 results returned in 0.4 sec, while 30 results took 0.9 sec, but that extra half a second lead to a loss of 20% of their traffic because users were impatient. User satisfaction is the golden rule of online services and so 10 results per page is now standard across all search engines regardless even though now days the difference is probably much less.

When it comes to ServiceNow, organisations should focus on user satisfaction as a way of increasing productivity. ServiceNow allows organisations to treat both their internal staff and their customers with respect, offering services that are snappy, intelligent and well designed. To this end, ServiceNow has developed a number of offerings including Virtual Agent.

What is Virtual Agent?

To say Virtual Agent is a chat-bot is disingenuous. Virtual Agent is a channel for users to quickly and easy get answers to their questions. It is a state-of-the-art system that leverages Natural Language Understanding (NLU) and a complex, decision-based response engine to meet a user’s expectations without wasting their time.

The Natural Language Understanding machine learning engine used by ServiceNow is trained to understand conversational chats using Wikipedia and The Washington Post, and can be enhanced with organisational specific words and phrases. Natural Language Understanding is the gateway for users to reach a catalogue of prebuilt workflows that resolve common issues.

The Virtual Agent Designer allows for sophisticated workflows with complex decision-making. Not only does this reduce the burden on first-level support it drastically reduces the resolution time for common issues, raising the satisfaction of users with the services provided by your organisation.

But the real genius behind Virtual Agent is it can be run from ANYWHERE

A common problem experienced by organisations with ServiceNow is managing multiple corporate websites. The ServiceNow self-service portal can be seen by some users as yet another corporate web instance and a bridge too far, reducing the adoption of self-service. To combat this, ServiceNow allows its Virtual Agent to be deployed ANYWHERE. As an example, it’s on this WordPress page! Go ahead, give it a try. As soon as you click on “chat”, you’re interacting with the JDSAustraliaDemo1 instance of ServiceNow!

By allowing the Virtual Agent to run from anywhere, customers can incorporate ServiceNow functionality into their other websites, giving users easy access to the services and offerings available through ServiceNow.

Keep your users happy. Start using Virtual Agent.

Using Common Functions in the Service Catalog

ServiceNow’s service portal offers a lot of flexibility for customers wanting to offer complex and sophisticated offerings to their users. Catalog client scripts can run on load, on change and on submit, but often there’s a need for a common library of functions to be shared by these scripts (so they’re maintained in just one place and produce consistent results).

For example, in this case, if the start date, end date or the SAP position changes, the same script needs to run to calculate who the approvers are for a particular request.

Rather than having three separate versions of the same script, we want to be able to store our logic in one place. Here’s how we can do it.

 

Isolate Script

Although the latest versions of ServiceNow (London, Madrid, etc) allow for scripts to be isolated or not, giving ServiceNow admins either the option of protecting (isolating) their scripts or accessing broader libraries, in practice, this can be a little frustrating to implement, so in our example, we’ll use an alternative method to introduce external javascript libraries.

 

UI Scripts

UI scripts, like the one listed below, are very powerful, but they’re also very broad, being applied EVERYWHERE and ALWAYS, so we’ll tread lightly and simply add a function that sets up the DOM for access from our client scripts.

As you can see, we now have some variables we can reference to give us access to the document object, the window object and the angular object from anywhere within ServiceNow.

In theory, we could attach our SAP position changes script here and it would be accessible but it would also be loaded on EVERY page ServiceNow ever loads, which is not good. What we want is a global function accessible only from WITHIN our catalog item, so we’ll put this in an ON LOAD script using our new myWindow object.

The format we’re using is…

myWindow.functionName = function(){

console.log('this is an example')

};

This function can then be called from ANYWHERE within our catalog item (on change or on submit). Also, notice the semi-colon at the end of the window function. Don’t forget this as it is important as we’re altering an object.

Now, though, any time we want to call that common function, we can do so with a single line of code.

 

Following this approach makes maintenance of the logic used by the approval process easy to find and alter going forward.

Conclusion

To learn more about how JDS can optimize the performance of ServiceNow, contact our team today on 1300 780 432, or email [email protected].

Glide Variables

ServiceNow uses a special type of super flexible variable to store information in what appears like a single field, but is actually a complex storage/management system with a database column type called glide_var.As each record can have a different number of variables stored as key/value pairs, there’s no easy way of dot-walking to the name of the variable within the glide_var as the names can change from record to record within the same table! You can, however, detect and retrieve variables from a glide_var by treating the gliderecord field as an object.

In this example, from an automated test framework step, you can see each of the variables and their values from the database glide_var column inputs.

var gr = new GlideRecord('the table you are looking at')
gr.get('sys_id of the record you are looking at')

for(var eachVariable in gr.inputs){
gs.info(eachVariable + ' : ' + gr.inputs[eachVariable])
}

If you run this in a background script you’ll see precisely which variables exist and what their values are.

It doesn’t need to be complicated! Reach out to us and we can help you.

Governance, Risk & Compliance

ServiceNow has implemented Governance, Risk and Compliance (GRC) based on the OCEG (Open Compliance & Ethics Group) GRP Capability Model.

What is GRC?

  • Governance allows an organisation to reliably achieve its objectives
  • Risk addresses uncertainty in a structured manner
  • Compliance ensures business activities are undertaken with integrity

Whether organisations formally recognize GRC or not, they all need to undertake some form of governance over their business activities or they will not be able to reliably achieve their goals.

When it comes to risk, recognising and addressing uncertainty ensures the durability of an organisation before it is placed in a position where it is under stress. Public and government expectations are that organisations will act with integrity; failure to do so may result in a loss of revenue, loss of social standing and possibly government fines or loss of licensing.

Governance, Risk and Compliance is built around the authority documents, policies and risks identified by the organisation as important.

Depending on the industry, there are a number of standards authorities and government regulations that form the basis for documents of authority, providing specific compliance regulations. ISO (the International Organisation for Standardization) has established quality assurance standards such as ISO 9000, and risk management frameworks such as ISO 31000, or ISO 27000 standards for information security management.

In addition to these, various governments may demand adherence to standards developed to protect the public, such as Sarbanes-Oxley (to protect investors against possible fraud), HIPAA (the US Health Insurance Portability and Accountability Act of 1996) and GDPR (the European Union’s General Data Protection Regulation). ServiceNow’s GRC allows organisations to manage these complex requirements and ensure they are compliant and operating efficiently.

The sheer number of documents and standards, along with the complexity of how they depend on and interact with each other, can make GRC daunting to administer. ServiceNow has simplified this process by structuring these activities in a logical framework.

Authority documents (like ISO 27000), internal policies and risk frameworks (like ISO 31000) represent a corporate library—the ideal state for the organisation. The question then becomes, how well does an organisation measure up to its ideals in terms of policies and risks?

ServiceNow addresses this by using profile types.

Profile types are a means of translating polices and risks into practice.

When policy types are applied to policy statements, they form the active controls for an organisation— that is, those controls from the library that are being actively monitored.

In the same way, when risks are applied to policy types, they form the risk register for the organization. This is the definitive list of those specific risks that are being actively measured and monitored, as opposed to all risks.

This approach allows organisations to accurately measure their governance model and understand which areas they need to focus on to improve.

The metrics supporting GRC profile types can be gathered manually via audit-styled surveys of employees and third-parties, or in an automated fashion using information stored elsewhere within ServiceNow (such as IT Service Management or Human Resources). In addition to this, GRC compliance metrics for the various profile types can be gathered using orchestration and automation, and by integrating with other systems to provide an accurate view of governance, risk and compliance.

If you would like to learn more about how ServiceNow can support your organisation manage the complexity of GRC, please speak to one of our account executives.

Conclusion

It doesn’t need to be complicated! Reach out to us and we can help you manage your organizational risks.

Asset Management in ServiceNow

Effective ICT departments are increasingly reliant on solid software and hardware asset management, yet the concept can often strike fear into the hearts of organisations as the complexity and work involved can seem endless. Indeed, Asset Management can be like trying to reach the moon with a step ladder! New advances in ServiceNow seek to change that ladder into a rocket - here’s how.


Business Goals (Launch Pad): Truly understanding your business goals and processes is an important and often underrated start to successful asset management. Clarifying business requirements allows us here at JDS to recommend suitable approaches to customers and help realise benefits faster. A recurring challenge we address is reducing unnecessary costs in over-licensed software. Through the power of ServiceNow technology, we can help you automate the removal and management of licenses.

Accurate Data (Rocket Fuel): Accurate data is the fuel behind asset management. With asset data commonly scattered across multiple systems, trusted data sources are paramount; often with organisations reliant on these to track and extract information for reports and often crucial decisions. JDS is experienced in tools such as ServiceNow Discovery and integrations with third-party providers like MicroFocus uCMDB, Microsoft SCCM and Ivanti LANDESK – proven solutions to assist management teams with data for business strategy.Using ServiceNow, we can help plan data imports/transformations to ensure information is accurate. This means asset info can be normalised automatically to improve data quality and ensure accurate reporting.

 

Asset Management on ServiceNow (Rocket Engine): With clear business goals and a focus on accurate data, ServiceNow also has further capabilities to propel your asset management process. Customers can now manage the lifecycle of asset management with refined expertise. JDS are champions of this automation process, particularly as proven benefits include streamlining and having an entire lifecycle consolidated and managed from one location, to greatly improve visibility and overall management.

 

Ongoing Management (Control Panel): With robust asset management now implemented, customers need a suitable control panel to help maintain momentum and drive continuous process improvement. Utilising a mix of existing ServiceNow and customised reports and dashboards, organisations are now able to easily digest data like never before.

Example of Software Asset Management

Example of Hardware Asset Management

Our team here are experienced in assisting customers setup ongoing asset reviews and audits on these platforms. One example of how we’ve customised this process, is by automating regular asset stocktake tasks, which can then be monitored and reported on the ServiceNow platform.

Conclusion

Successful Asset Management can be a journey, yet well worth the effort by significantly improving on processes and reducing operational costs. Our team are experts in devising solutions with customers, to realise and maximise the value of efficient asset management; and help firmly plant your organisation’s foot and flag on the moon!

Conclusion

Need help in planning and implementing a robust asset management solution? Reach out to us with your current challenges, we would love to help.

Accelerate upgrades with ServiceNow Automated Test Framework

Upgrade more often

In 2019, ServiceNow will move to “N-1” upgrades, meaning you can’t be more than one release behind before ServiceNow will force the upgrade to your platform, ready or not.

It’s nothing to be afraid of. The evolution of enterprise to the cloud means we can break free from the shackles of the old on-premise software model. ServiceNow takes care of all the back-end technical changes, which eliminates a lot of the burden that has made upgrades slow and expensive.

Your challenge now is to make sure that nothing in the upgrade process disrupts your business. Test automation with ServiceNow ATF can help – see our technical post here for more on that.

Accelerate test automation with JDS Kick Start

We can help you get started with ServiceNow ATF. In just a few days, the JDS ServiceNow ATF Kick Start engagement will provide you with the detail you need to scope and plan automation of testing across your platform.

JDS brings over a decade of experience in test automation, and our experienced ServiceNow team can help with a rapid assessment of your platform.

JDS ServiceNow ATF Kick Start includes:

  • Identification of the top use cases that are candidates for automation
  • Joint review and refinement of use cases
  • Report and recommendations for automation

Call us

To find out more and to book a Kick Start – email [email protected] or call 1300 780 432 to reach our team.

We partner with leading technologies

Fast-track ServiceNow upgrades with Automated Testing Framework (ATF)

Why automate?

ServiceNow provides two releases a year, delivering new features to consistently support best practice processes. ServiceNow has flagged they will move towards “N-1” upgrades in 2019, meaning every customer will need to accept each release in the future. To keep up, ServiceNow customers should consider automated testing. This can provide regression testing, completed consistently for each release, and reduce the time and effort needed per upgrade. Effective test automation on ServiceNow is provided by the Automated Testing Framework (ATF), which is included in the ServiceNow platform for all applications. It enables no-code and low-code users to create automated tests with ease. Aided by complementary processes and methodology, ATF reduces upgrade pain by cutting back on manual tests, reducing business impact and accelerating development efficiency.

What is the Automated Test Framework?

Testing frameworks can be viewed as a set of guidelines used for creating and designing test cases. Test automation frameworks take this a step further by using a range of automation tools designed to make the practice of quality assurance more manageable for testing teams.

ServiceNow’s ATF application combines the above into an easy to use and implement solution specifically for ServiceNow applications and functionality. Think of ATF as a tool to streamline your upgrade and QA processes by building tests to check if software or configuration changes have potentially ‘broken’ any existing functionality. It also means developers would no longer be required to start invasive activities like code refactoring to generate new test cases.

Overview of test creation in ServiceNow ATF - click to enlarge

ATF’s unique features include:

  • Codeless setup of test steps and templates (reusable across multiple tests)
  • Testing Service Catalog from end-to-end including submitting Catalog forms and request fulfilment
  • Module testing e.g. ITSM (Incident, Problem & Change Management)
  • Testing forms in the Service Portal (Included in London release)
  • Batching with test suites e.g. Execute multiple tests in a defined order and trigger based on a schedule
  • Custom step configurations & unit testing using the Jasmine test framework
       

Using the codeless test step configuration in ATF to set a Variable value on a Service Catalog form

Simplify your upgrades

For most software upgrades, testing is a burdensome and complicated process, with poorly defined test practices often leading to compromised software quality and potentially, failed projects. Without automation, teams are forced to manually test upgrades - a costly, time-consuming and often ineffective exercise. In most cases, this can be attributed to a lack of testing resources and missing test processes, leading to inconsistent execution.

To address these, ATF introduces structure and enforces consistency across different tests applied to common ServiceNow use cases. Test consistency is important, as this forms a baseline of instance stability based on existing issues, meaning defects caused by upgrades are more reliably determined. ATF allows for full automation of test suites, where the run order can be configured based on tests that depend on each other.  

The following illustrates a simple test dependency created in ATF:

An example ‘hierarchical’ test structure implemented within ATF

A common issue resolved by automated testing is the impact on Agile development cycles. Traditionally, developers would run unit tests by hand, based on steps also written by the developer, potentially leading to missed steps and incomplete scenarios. ATF can be used to run automated unit tests between each build cycle, saving time through early detection and remediation of software issues along with shortened development cycles. The fewer issues present before the upgrade, the fewer issues introduced during the upgrade.

A common requirement of post-upgrade activities is to execute a full regression test against the platform. This means accounting for countless business logic, client scripts, UI policies and web forms that may have been affected. Rather than factoring all of these scenarios into lengthy UAT/Regression cycles, ATF can reduce the load on the business by running those common and repetitive test cases involving multiple user interactions and data entry.

The below example shows how a common use case for testing, field ‘state’ validation on a Service Portal form, is applied using the test step module:

Validating visible & mandatory states of variables with ATF against a Record Producer in Service Portal

Unfortunately, not everything can be automated with ATF out of the box, there are some gaps that are a result of complex UI components, portal widgets and custom development work. It is also important to note custom functionality will add overhead to the framework implementation, and will require specialised scripting knowledge and making use of the ‘Step Configurations’ module to create custom test steps.

When configured properly, it’s possible to automate between 40-60% of test cases with ATF depending on environment complexity and timeframes. The benefits can largely be seen during regression testing post-upgrade, and unit testing during development projects.

In summary, implementing an ATF is a great way of delivering value to ServiceNow upgrade projects and enabling development teams to be more agile. Assessing the scope and depth of testing using an agreed methodology is a great way to determine what is required, and to achieve ‘buy-in’ from others, rather than taking the ‘automate everything’ approach.

JDS is here to help

Recognised as experts in the local Test Automation space for over 12 years, JDS' specialist team has adapted this experience to provide a proven framework for ServiceNow ATF implementation.

We have developed a Rapid Automated Testing tool which can use your existing data to take up to 80% of the work out of building your automated tests. Contact us today to find out how we can build test cases based on real data and automate the development of your testing suite in a fraction of the time that manual test creation would require.

We can help you get started with ServiceNow ATF. In just a few days, a ServiceNow ATF “Kick Start” engagement will provide you with the detail you need to scope and plan ATF on your platform.

Conclusion

Want to know more? Email [email protected] or call 1300 780 432 to reach our team.

Our team on the case