ServiceNow is a cloud-based enterprise AI platform offering a wide range of solutions for customer service, HR, security, and generative AI, and agentic AI. Organizations of all sizes use the Now Platform for their service desk, change management, and automation needs.
According to ServiceNow's official report, it is one of the fastest-growing enterprise software companies, having reached $12.8B in organic revenue and boasting a 98% renewal rate. It serves nearly 8,400 organizations, including more than 85% of the Fortune 500. These figures indicate the increasing demand for ServiceNow administrators, developers, testing specialists, and other professionals.
This guide is organized as follows:
ServiceNow is a cloud-based enterprise platform that automates and streamlines business workflows across departments such as IT, HR, Customer Service, Finance, and Security, all on a single, unified platform called the Now Platform.
Now Assist is the generative AI assistant of ServiceNow that is embedded in ITSM, CSM, HRSD, and Creator workflows. Typically configured skills include incident or case summarization, "Resolution Note" generation, Knowledge Article generation, and development code generation. It enhances agent productivity by providing intelligent recommendations.
For more advanced needs, tailored AI skills may be developed using the "Now Assist Skill Kit" (NASK).
An asynchronous business rule is activated after a change is saved to the database (similar to an after rule); however, it runs as a scheduled task. This doesn't keep the user's current task from proceeding. Control is returned to the user, and the related updates occur slightly later.
They are best for longer-running tasks or tasks where it's okay to delay, and for operations that span multiple transactions (such as external integrations, bulk data updates, emails).
AI Agent Studio is a development tool in the ServiceNow AI Platform that helps you build and customize specialized AI agents, establish guardrails, and automate tasks using natural language search. Agents are coordinated via the AI Agent Orchestrator into an agentic workflow (the business goal or process, such as incident triage and categorization), and governance is routed to the central AI Control Tower.
A solid design-and-govern answer for incident triage:
Indeed, the governance story (guardrails, human-in-the-loop (HIL) when there is low confidence, audit, measurable metrics etc.) is that which distinguishes a strong answer from “I built an agent”.
Australia Release 2026 is the latest version and the first release under ServiceNow's new country-based naming. Prior to Australia, the latest release was Zurich (Q4 2025).
In ServiceNow, an application is a group of modules, tables, and business logic that serves a specific business function. For example, a change application provides information related to the change process. It consists of modules such as creating and viewing change tickets.
CMDB baselines help understand and control changes made to a configuration item (CI) after its Baseline has been created. The baseline is the snapshot of a CI.
In ServiceNow, ATF automates functional/regression testing using reusable test steps and Test Suites. It also works to validate applications, customizations, and integrations prior to upgrades or deployments.
When running the ATF in sub-production calls before any production changes or improvements have been made, regression issues can be detected at an early stage. Functional testing, not performance/load testing, is the main purpose of ATF.
A GlideRecord is ServiceNow's server-side API for communicating with your tables and database. You use GlideRecord to retrieve records from any table: insert them, update them, and delete them with addQuery, addEncodedQuery. Instantiate it with a table, query for records with various filters, get them using 'next()' and 'query()', and iterate over the results.
Set limits using 'setLimit()' and only query indexed fields to speed up transactions. It's critical to note that ACLs are bypassed on server-side GlideRecord, and if your permission level needs to be respected, use GlideRecordSecure instead.
The view defines the arrangement of fields on a form or a list. For a single form, we can define multiple views based on user preferences or requirements single form, we can define multiple views based on
An ACL is an access control list that defines what data a user can access and how they can access it in ServiceNow.
Impersonating a user lets you log in to the system as that user and see how the ServiceNow UI is configured for them. This is very useful while testing.
For example, if you are required to test whether a user can access the change form. You can impersonate that user and can test instead of logging out from your session and logging in again with that user's credentials.
A record producer is a catalog item type that allows users to create task-based records from the service catalog.
For example, you can create a change record or problem record using a record producer. Record producers provide an alternative way to create records through the service catalog item type.
Dictionary Overrides allows you to override several properties of a field in an extended table. For example, a changing table is extended from the task table. There is a field named status in the task table that is set to read-only.
When we use this field in the change form, it will show as read-only. We can set this to non-read-only by using the dictionary override. Similarly, other properties can be set for fields in an extended table.
Coalesce is a field property we use in transform map field mapping. When we set coalesce to true for a field mapping, it indicates that this field will serve as a unique key.
If a field match is found with the coalesce field, the existing record in the target table will be updated with the imported information; otherwise, a new record will be inserted into the target table.
UI policies are alternatives to client scripts. It can be used to set a field as mandatory, read-only, and visible on a form. You can also use UI policy for dynamically changing a field on a form.
Data policy checks whether a field is mandatory or read-only whenever a record is inserted or updated through a web service or import set.
For example, if a mandatory field in the incoming record (from an import set or a web service) is empty, the data policy will prevent the record from being inserted into the table.
UI policy applies when a record is inserted or updated through the ServiceNow UI (i.e., ServiceNow forms), while data policy applies whenever a record is inserted or updated into the database by any means.
Client script sits on the client-side(the browser) and run there only types of client script are OnLoad(), OnSubmit(), OnChange(), and OnCellEdit()
In the onSubmit function, return false. function onSubmit() { return false;}.
A business rule is server-side scripting that executes whenever a record is inserted, updated, deleted, displayed, or queried.
The key thing to keep in mind while creating a business rule is when and on what action it has to execute. You can run the business rule ‘on display, ‘on before’, or ‘on after’ of an action (insert, delete, update) is performed.
No, we cannot directly call a Business Rule from a Client Script. Business Rule runs server-side while Client Script runs client-side (Browser). To bridge the gap, we use GlideAjax to make an asynchronous server call from a Client Script.
The data lookup and record matching feature helps to set a field value based on some conditions instead of writing scripts.
For example, on Incident forms, the priority lookup rules sample data automatically sets the incident Priority based on the incident Impact and Urgency values. Data lookup rules allow specifying the conditions and fields for which data lookups should occur.
An updated set is a group of customizations. It captures the customization or configuration changes made by a user, and then these update sets can be moved from one instance to another.
For example, if we made configuration changes in our development environment and want those changes in our test environment, we can capture all the changes in an updated set and move it to the test environment instead of making changes manually.
A unique 32-character GUID that identifies each record created in each table in ServiceNow.
Completed Flow actions cannot be simply erased. Instead, it's designed to be idempotent, to prevent duplicate or incorrect updates when they are rerun, to have guard conditions so they don't run when something is wrong, and to include compensation steps to undo what was done.
Create a Record trigger on the Incident table that creates a Flow Designer flow. If necessary, add conditions and add the custom Action as a flow step. Today, it is preferred over Business Rules; however, that's not the same approach.
| Concept | What it is | Has a Trigger |
| Flow | A complete automated process: a trigger plus an ordered sequence of steps (e.g., on Critical Incident → notify manager, assign group, create problem) | Yes |
| Action | The smallest building block — a single reusable step such as "Create Record," "Send Email," or "Call REST API" | No (runs inside a flow/subflow) |
| Subflow | A reusable sequence of actions with defined inputs and outputs, called from a flow, another subflow, or a script | No — subflows lack a trigger |
The clean summary: Use Flows for complete processes, Subflows for reusable sequences shared across Flows, and Actions for the smallest, most repeatable tasks. Subflows are the "functions" of Flow Designer — define once, reuse everywhere.
A scoped application is unique in that its own namespace, limited APIs, and isolated resources do not interfere with other applications. This is safer, easier to maintain, and acceptable for deployment on the ServiceNow Store.
A global application can offer broader access and fewer restrictions, making it more powerful but also more dangerous. For most of their modern custom development, ServiceNow suggests scoped applications.
On one of the ITSM projects I worked on at my previous organization, onboarding access requests were handled entirely manually. It had a fulfiller read each ticket, create tasks, and route approvals by hand. As a lead developer, I rebuilt it as a Service Catalog item on a Flow Designer flow, using a reusable approval subflow and a decision table to route by department. I chose Flow Designer over a legacy workflow because it's the modern, upgrade-stable approach.
As a result, routine requests were fulfilled with minimal manual touch, reducing handling time and routing errors. However, the decision-table design took longer to build than separate flows, but was far easier to maintain. I also left a manual review step for rare cases rather than over-engineering the automation.
Early in a release, I committed an update that was set straight to production with a Business Rule that ran on every Incident insert and update. It passed testing, but slowed things down under load because I had skipped the proper preview-and-promote process. When the alerts hit, I disabled the rule and fixed the unscoped trigger condition. I also re-promoted a smaller set of updates through dev and test. I even ran a Health Scan to confirm there were no other regressions.
Response times were recovered within the hour, but the bigger change was to my process. I moved to one update set per change request, made develop-complete-test-promote non-negotiable, and stopped editing production directly. I also started writing short post-incident notes to help the whole team learn. That discipline has prevented similar incidents since then.
These questions target the developer track, scripting, integrations, and security. They reflect the kinds of questions reported for ServiceNow developer roles at firms such as Wipro, Deloitte, Infosys, and more.
To get smaller groups of records, use pagination via the sysparm_limit and sysparm_offset parameters. Use filters via sysparm_query and columns via sysparm_fields to eliminate extra rows and columns. Having paged responses avoids memory and performance problems.
Use query parameters in the API request. For complex filters, use sysparm_query with encoded queries like active=true^state=2. For simple equality checks, direct parameters like ?active=true also work. Add sysparm_fields and sysparm_limit to reduce returned data.
Design a REST message for the endpoint URL and HTTP methods. Set up client ID, secret, and token URL for OAuth 2.0 using an OAuth profile. For large data sets, paginate using the limit/offset or next-page token. Use good data mapping, error handling, and logging as you repair the response with JSON.parse and validate the status codes. Try out test integrations via REST API Explorer and securely store credentials.
LDAP is the Lightweight Directory Access Protocol. It is used for user data population and User authentication. ServiceNow integrates with the LDAP directory to streamline the user login process and automate user creation and role assignment.
A Business Rule is the answer interviewers are looking for. Business rules are server-side functions that execute when a server record is displayed, inserted, updated, or deleted, or when a server table is queried. A common use is to update or modify the value of a field when one or more conditions are true.
If the action has to take place before the record is written, for instance, a default or the calculation of a field value, then you will create a before business rule as it will execute after the form is submitted, but before the database action is performed. If the field change should be reflected in the form the user is viewing, a Display business rule passes server data to the client via the g_scratchpad object.
For field automation that the user triggers interactively on the form (without saving), developers reach for a Client Script or a UI Policy instead.
gsftSubmit is the client-side function used to programmatically submit a form (and optionally trigger a specific UI Action) from a Client Script or UI Action. The common pattern is:
// Submit the form and fire the UI Action whose action_name is "my_action"
gsftSubmit(null, g_form.getFormElement(), 'my_action');
A common interview pattern combines client and server logic in a single UI Action: the client-side portion runs first, calls gsftSubmit to resubmit the form, and, on the second pass, the server-side portion executes.
Because this is a legacy platform global rather than a documented public API, treat it as a known idiom and be ready to explain why you'd use it (running client validation before server processing in one UI Action) rather than reciting it as official syntax.
| API | Use it for | ACL Behavior |
| GlideRecord | Standard CRUD and querying of records row by row | Bypasses ACLs by default (system privileges); needs manual canRead()/canWrite() |
| GlideAggregate | Counts, sums, averages, min/max, and GROUP BY-style aggregation — without looping through every record | Aggregation API; use instead of counting in a loop for performance |
| GlideRecordSecure | The same operations as GlideRecord, when you must respect the current user's permissions | Automatically enforces ACLs |
My advice is as follows: If you just need to do a count or a rollup, use GlideAggregate; if you're supposed to query data on behalf of a user for whom you care whether the data is accessible, use GlideRecordSecure.
If you want to resort to whatever you like to avoid ACLs by design, use GlideRecord.
The data dictionary defines every table and field in the system. It contains information about a field’s data type, default value, dependency, and other attributes.
You need the security_admin role to create or update ACLs in ServiceNow.
Go to System Diagnostic > Stats in the navigator. The statistics page will be open, where you can view details about the node and the instance you are working on.
You query the user's record on the server side using GlideRecord and read the manager field. A clean way to expose this to a form is via a Script Include called from the client with GlideAjax:
// Script Include (client-callable)
var GetUserDetails = Class.create();
GetUserDetails.prototype = Object.extendsObject(AbstractAjaxProcessor, {
getManager: function() {
var gr = new GlideRecord('sys_user');
if (gr.get(this.getParameter('sysparm_user_id'))) {
return gr.manager.toString(); // returns the sys_id of the manager
}
return '';
},
type: 'GetUserDetails'
});
The client script then calls getManager through GlideAjax and sets the field with g_form.setValue('manager', answer).
ServiceNow's own GlideAjax example demonstrates exactly this, fetching the logged-in user's manager from sys_user inside a Script Include and returning it to the form.
Import Sets is a tool used to import data from various data sources and, then, using a transform map, transform the data into ServiceNow tables. The Import Sets table serves as a staging table for imported records.
A transform map transforms the record imported into the ServiceNow import set table to the target table. It also determines the relationships between fields displayed in an Import Set table and fields in the target table
A foreign record insert occurs when an import modifies a table that is not the target table for that import. This happens when updating a reference field on a table.
An inactivity monitor triggers an event on a task record if the task has been inactive for a specified period. If the task remains inactive, the monitor repeats at regular intervals.
Ans: Domain separation is a way to partition data into (and optionally administer) logically defined domains.
For example, a client, XYZ, has two businesses and is using a single ServiceNow instance for both. They do not want users from one business to see the data from other businesses. Here, we can configure domain separation to isolate the records from both businesses.
Leave an Inquiry to learn about: ServiceNow Online Training in Bangalore
The HTML sanitizer is a security feature that automatically cleans HTML markup in HTML fields, removing unwanted code and helping protect against security concerns such as cross-site scripting attacks. In Australia Release 2026, it is enabled by default as a part of ServiceNow's security governance framework.
ServiceNow uses the Sys Audit [sys_audit] table to audit changes to records.
The schema map displays table details and their relationships visually, allowing administrators to easily view and access different parts of the database schema.
Goto Go to the dictionary of the respective date-time field and set the default value as JavaScript: gs.now DateTime;
set workflow (e) enables or disables the running of business rules that might normally be triggered by subsequent actions. If the e parameter is set to false, an insert/update will not be audited. Auditing only happens when the parameter is set to true for a GlideRecord operation.
Parameters: e - A boolean variable that, if true (default), enables business rules, and if false, disables them.
This is a behavioral prompt — answer it with a concise STAR-style story rather than definitions. A strong template:
"On a recent project, we needed bidirectional ticket sync between ServiceNow and a third-party monitoring tool. I owned the integration design: outbound calls used a REST Message secured with OAuth 2.0, and inbound updates came through a Scripted REST API.
I added pagination handling and field mapping, built error logging so failed messages were retried, and wrote ATF tests for the inbound endpoint. The result was a near-real-time sync that eliminated roughly a day of manual ticket reconciliation each week. If I did it again, I'd add a dead-letter queue earlier instead of bolting it on later."
"Support each claim explicitly with specific decision(s) and measure(s). Interviewers are interested in your reasoning process for balancing factors and not in the list of tools."
An async business rule is a server-side script that runs after the database commits a change, similar to an after rule, but it runs in the background, scheduled by the system scheduler, rather than as part of the user's transaction. Because it runs asynchronously, the system returns control to the user sooner, though related objects may take a little longer to update.
Use async rules for work that shouldn't make the user wait: long-running operations, bulk updates across many related records, sending email, or making calls to external systems. ServiceNow's guidance is that you can often use an async rule in place of an after rule to improve the user experience, reserving synchronous after rules for work that must complete within the transaction.
All three are GlideAjax methods used in client scripts to retrieve a response from a server-side Script Include, but they differ in how they wait and what they return:
| Method | Call Type | Behavior |
| getXML(callback) | Asynchronous | Places a non-blocking call; control returns to the client immediately and your callback handles the XML response |
| getXMLWait() | Synchronous | Blocks (freezes) the client until the server responds — discouraged for production and not supported in Service Portal |
| getXMLAnswer(callback) | Asynchronous | Like getXML, but returns only the answer element directly, sparing you from parsing responseXML.documentElement.getAttribute("answer") |
In practice, use getXMLAnswer to make clean, asynchronous calls. There are situations in which you do need to block (e.g., an onSubmit decision), but getXMLWait is not recommended by ServiceNow because it negatively impacts UX in poor network connection scenarios and causes breaks in the Service Portal (which is built with AngularJS).
Outbound integration means that ServiceNow makes the call to an external system: For example, a REST Message being pushed to a third-party tool to create an incident. ServiceNow stores how to reach the external service in a REST Message record (including endpoint, authentication, and HTTP method), and outbound REST supports both Basic authentication and OAuth 2.0.
For inbound OAuth, ServiceNow uses the Authorization Code and Resource Owner Password Credentials grant types, which are interconnected with other services, such as an Application Registry record on System OAuth.
The Mental Model: Outbound = ServiceNow is the Client, Inbound = ServiceNow is the Server.
A UI Action can contain both client-side and server-side logic. To run server-side code, either:
You can also call a Script Include from the server-side to reuse logic.
The suggested, and usually most popular, way is to use GlideAjax, which makes an asynchronous call to a Script Include callable from the client and returns data without stopping the client.
The general pattern is: create a GlideAjax object naming the Script Include class, add the method name via addParam('sysparm_name', ...), add any other parameters, then execute with getXMLAnswer(callback).
Other (less preferred) techniques include g_form.getReference() with a callback, and g_scratchpad populated by a Display business rule for data needed at form load. Client-side GlideRecord still exists in the global scope, but is deprecated and strongly discouraged because it issues synchronous calls that freeze the browser; use GlideAjax instead.
In an ACL, the format is table.field. A none (or *) field component does not correspond to any specific field; it indicates an operation at the level of the table (record). Therefore, if the none field is used for accesses, the whole record/operation will be restricted; and if table.* is used for accesses, all field accesses not covered by a more specific field-level ACL will be restricted.
A ServiceNow will process the most specific matching at the table/record level ACL first and will check field-level ACLs in parallel with the table/record-level ACL. The user must pass both the table-level and field-level ACLs to gain access. This means that if the field-level wildcard type matches, it won't prevent the record-level wildcard type from matching.
Be ready to explain that ACLs are evaluated with an implicit "deny unless granted" stance and that both the condition and the script (if present), plus the required role, must all pass.
Use an onChange Client Script (or an onSubmit for final validation) with a regular expression that rejects anything outside letters and digits:
function onChange(control, oldValue, newValue, isLoading, isTemplate) {
if (isLoading || newValue === '') {
return;
}
var alphanumeric = /^[a-zA-Z0-9]+$/;
if (!alphanumeric.test(newValue)) {
g_form.showFieldMsg('u_my_field', 'Only alphanumeric characters are allowed', 'error');
g_form.setValue('u_my_field', oldValue); // revert invalid input
} else {
g_form.hideFieldMsg('u_my_field', true);
}
}
For robustness, pair the client check with a server-side check before the business rule using the same regex, so the rule is enforced even when records are created through lists, imports, or web services.
Walk the interviewer through a systematic path rather than a single fix:
Framing it as ECC Queue → Discovery Status → MID Server → credentials/network → IRE shows you understand the data flow, which is what interviewers reward.
Bidirectional integration means data flows both ways, so you design two halves and keep them consistent:
To prevent infinite update loops, add a guard — for example, a "source" flag or a correlation ID so each side can recognize updates it originated and skip echoing them back. Layer in error handling, retry logic, and logging, and use a correlation/external reference field to keep the two records linked. IntegrationHub spokes can replace custom scripting for many common targets.
setForceUpdate() updates the record even if there are no changes on the record.
set limit(n) functions to limit the number of records to query by Gliderecord().
GlideRecordSecure automatically applies ACLs to the current user. It does not attempt to read or write even when the file is not allowed to be read or written, if that is the case, unlike GlideRecord. Always use GlideRecordSecure when the criteria for user access to a query must be followed.
Display the pop-up after login using one of the following methods: onLoad UI Script, UI Page, or Service Portal widget. Keep a flag on the user record indicating whether they have accepted the disclaimer; if so, don't ask them again.
Yes, you can do it using the autoSysFields() function in your server-side scripting. Whenever you update a record, set autoSysFields() to false.using the autoSysFields() function.
Example:
var gr = new GlideRecord(‘incident’);
gr.query();
if(gr.next()){
gr.autoSysFields(false);
short_description = “Test from Examsmyntra” ;
gr.update();
}
By using the getRowCount() function, you can retrieve the number of rows.
Follow the Rule of Least Privilege: Implement relationship-based development, and do not rely on roles as ACLs. Experience cloud-based enterprise REST API for deployment while retaining the ability to create read ACLs like caller_id or opened_by against gs.getUserID().
Use ACLs in conjunction with a before-query Business Rule that limits access to records to improve control.
delete multiple() deletes multiple records according to the current “where” clause. Do not delete attachments; use delete record() to delete a single record.
The following is the stepwise process:
Go to the dictionary of that table and add “Add no_attachment” to the Attributes field.
Metrics record and measure the workflow of individual records. With metrics, customers can arm their processes with tangible figures to measure, for example, how long it takes for a ticket to be reassigned or to change state.
Use any of the following searches to find information in ServiceNow:
Navigate to Reports > Create New → select Table, define Conditions/Filters, choose Report Type (Bar, Pie, List, etc.), configure grouping, and click Run → Save.
In the Australia release 2026 update, ServiceNow has enhanced reporting with AI-assisted report generation via Now Assist.
A few reports are:
Navigate to System Policy > Email > Inbound Actions and Click New.
Via Watermark or InReplyTo email header. If these are not present, ServiceNow recognizes an email containing a prefix in the subject line.
| Explore ServiceNow Sample Resumes Download & Edit, Get Noticed by Top Employers! |
Each update set is stored in the Update Set [sys_update_set] table, and the customizations that are associated with the update set, are stored in [sys_update_xml] table.
If the Default update set is marked Complete, the system creates another update set named Default1 and uses it as the default.
Homepages and content pages are not added to update sets by default. You must manually add pages to the current update set by unloading them.
Reference qualifiers restrict the data that can be selected for a reference field.
Performance Analytics is an additional ServiceNow application that allows customers to take snapshots of data at regular intervals and create time series for any key performance indicator (KPI) across the organization.
Navigate to User Administration > Roles and click New → enter the Role Name → add Description, and assign Contains Roles.
You can use the addActiveQuery() method to get all the active records and the addInactiveQuery() method to get all inactive records.
addJoinQuery(joinTable, [primaryField], [joinTableField])
Note: This is not a true DATABASE Join. addJoinQuery() adds a subQuery.
g_form object is used to reference the currently active form in the client script.
You can use the g_user object to get the details of the currently active user.
A few of the best practices to use client Scripts :
You can use the g_form.setVisible(‘field name’, ‘value’); method to show/hide a field using client script.
Record ACL rules are processed in the following order:
addNotNullQuery(String fieldName) can be used.
Example: To get all the records where ‘name’ is not null.
addNotNullQuery(‘name’);
Use addOrCondition(String name, String oper, Object value)
Example :
var gr = new GlideRecord(‘incident’);
var qc = gr.addQuery(‘category’, ‘hardware’);
qc.addOrCondition(‘category’, ‘software’);
gr.query();
By using the method changes() you can determine that the field value has been changed for a record.
Visit Here to Learn: ServiceNow Online Training in Hyderabad
The following are key skills that a ServiceNow professional should have:
Yes. ServiceNow skills remain highly relevant in IT, and with the launch of Now Assist and agentic AI, new specializations are emerging among buzzy learners.
Yes. Even if you're a newbie or an experienced pro, you can easily build a successful career with ServiceNow. All you need for a stable ServiceNow career is to acquire the right ServiceNow training and go over the top ServiceNow interview questions, and you'll be ready to land a job in ServiceNow.
According to AmbitionBox, in India, ServiceNow Developers can earn an average of ₹4 to ₹10 Lakhs per year, while ServiceNow Admins can earn ₹4 to ₹7 Lakhs per year.
Follow the Certified System Administrator (CSA) qualification and then explore one of the Certified Application Developer (CAD) or one of the Certified Implementation Specialist (CIS) domain-specific options (ITSM, CSM, HR, etc.).
As a ServiceNow developer, you can work as one of the following:
These ServiceNow questions and answers should help hone your basic knowledge and your ability to use scenarios across the developer track, freshers/experienced track, and AI. Combined with the hands-on learning you'll get in a PDI and at least one certification, you'll feel ready to go in your interview and back up every answer with real-world experience with the platform.

Our work-support plans provide precise options as per your project tasks. Whether you are a newbie or an experienced professional seeking assistance in completing project tasks, we are here with the following plans to meet your custom needs:

Ravindra Savaram is a Technical Lead at Mindmajix.com. His passion lies in writing articles on the most popular IT platforms including Machine learning, DevOps, Data Science, Artificial Intelligence, RPA, Deep Learning, and so on. You can stay up to date on all these technologies by following him on LinkedIn and Twitter.