ServiceNow Studio Basics

0:01Hi, Sean here and welcome to this skill where we're going to be taking a look at the basics of using something called the ServiceNow Studio to put applications together. So at this point in the course, we've seen a lot of different pieces of creating applications, right? We've taken a look at, you know, things like business rules. We've taken a look at automation, like using flows, sub flows, actions. We've taken a look at, you know, access management and the details of application scope. So we've taken a look at an awful lot of things now, and this is really the tool where all of these things are going to come together.

0:38Literally, they're all going to be incorporated into this new tool that's kind of similar to the form builder tool that we saw in earlier skills, except for entire applications, right? So let's just open this thing up. You can get there by going to all, and you're going to search for ServiceNow Studio. Now, the annoying thing about this, right, as with many things in ServiceNow, is that there's an older tool with a very similar name. It's called Studio. And so besides making this thing very difficult to Google, right, when you Google ServiceNow Studio, sometimes it comes up with the old Studio tool from ServiceNow, and sometimes it comes up with a new ServiceNow Studio tool from ServiceNow.

1:23I don't know why they choose to do this to me continuously, but anyway, let's just open this up. You can get there from App Engine or Process Automation or wherever you want, and here is ServiceNow Studio. So again, as I said, this is a very similar idea to what we saw with the form builder tool, right? With the form builder tool, what we saw is that there's a lot of things like UI policies, and we have the table config that we have to worry about, and we have things like client scripts, and we have data policies.

2:05And all of this, you know, if you set up a form, right, if you want to set up a form to behave exactly the way you want it to in ServiceNow, typically you would have to bounce around to all of these different modules, right? You'd have to go to the UI policies module, the tables module, the client scripts module, the data policies module. You'd have to bounce around and hope that you didn't forget anything. And the cool part about the form builder, whoops, let me try writing that again. There we go.

2:35The cool part about the form builder is that it brought all of these things together in a single centralized place. So from the form builder, you could easily add new UI policies or new client scripts or new table configurations, right? And so that's the same basic idea here that we're going to be seeing for the ServiceNow Studio tool, except it does this at a much larger scale, right? So in addition to all of these things, which you can also do, the ServiceNow Studio, and here I'm just going to remove form builder and write ServiceNow Studio here, right?

3:16ServiceNow Studio brings all these things together for when you're creating an application, but it also includes things like if you're building flows or workflows, it brings together the actual individual forms that you're working with as well. It brings together all of the access control rules that you need for your application, right? And many, many, many, many, many other things, all right? We're going to see this in much more detail as we go along. But that's the basic idea here is that it provides you with like a centralized place to actually manage all of these things.

3:50And also, like what we saw with the form builder, I realized that that was earlier in the course. But also, as we saw with the form builder, ServiceNow Studio will actually be performing all of those same actions behind the scenes. So when we create a UI policy in the ServiceNow Studio, it's going to create a UI policy behind the scenes. When we create a flow in the ServiceNow Studio, it's going to create a real flow behind the scenes. When we add a column to a table in ServiceNow Studio, it's going to add a column to that table in the actual data behind the scenes.

4:24All right. So anyway, hopefully that helps to kind of set the scene for what we're going to be talking about here. All right. But anyway, now that we're kind of familiar with that, let's get started here. So again, open up the ServiceNow Studio. And what we're going to do is we're going to click this little create dropdown, and we're going to say that we want to create a new application. Okay. So here's what we're going to do. As just a simple example, we're going to create an application called something like My First App.

4:54Kind of a boring name, but, well, we'll just go with it for now. For the description, what we're going to do is we're just going to say something like a quick walkthrough app to show how SN Studio works with a few exclamation points at the end, of course. All right. And then we're going to set this to scoped. Right. Now, you can set the application to global if you want to, but, you know, a few skills ago we talked about why this is a bad idea.

5:25So you're typically going to want your applications to be scoped because you want them to be isolated from all of the other kind of details in ServiceNow. You want them to be isolated from other applications and what's going on in the global scope as much as possible. Okay. All right. Notice that you can also add a picture to this, so feel free to add whatever you happen to have lying around just for fun. I'm going to leave that one blank, though. And we're going to say continue. And notice that this kind of walks you through a few of the core pieces in configuring an application.

6:00So the first thing here is it asks you to create a default role. All right. So as you can see, the role name here is admin. The description for this is the default admin role. And then we have the user role, which is just kind of the default role that a user of the application would have. Now, this is a good starting point, right? It's already a good idea to have some sort of separation between people who are actively working on the app and people who are going to be working in the app, right?

6:33Admins are typically people who are going to be working on the app. Users are the ones who are going to be working in the app. So you can add new roles to this, right? And if you plan on having multiple different types of users, right, maybe there's admin, then maybe there's internal employee, then maybe there's contractor, right? There's lots of other ways you could slice it as well. But just to give you an idea of what's possible with that. So for now, we're just going to leave that the way it is and click continue. And it's going to tell us to sit tight while it creates the app.

7:04And so I'm just going to fast forward this part. And when it's done, we should see our app. And there it is. I actually didn't have to fast forward that. It was faster than I thought it would be. So we're going to say go to app dashboard. And here we see the main dashboard for our app. All right, so the main idea here, and I'm just going to collapse this for a second so we can see it a little bit more clearly. The main idea here is that instead of having all of those tables, right, like flows and table configurations and UI policies, et cetera, all kind of in different places in ServiceNow.

7:38The ServiceNow Studio interface here kind of tries to bring them together in the same way as like if you're working on a software project. You have all of the files inside the same directory or set of directories, right? So this is ServiceNow trying to follow that same basic strategy because, frankly, it just makes a lot of things a lot easier when you have them all kind of in the same place and don't have to spend half your time hunting through the ServiceNow modules for them. All right, so here's what we're going to do.

8:10Feel free to look through all of this stuff here, and you can already see most of the application files that are associated with this, right? So there's four right now. Two of them are the roles that just got created. So we have the admin role and we have the user role. And then we have these two other things here, which are things known as embedded help role priorities. So don't worry about what those are right now. What we're going to do next, and you can also look through things like dependencies, which is empty.

8:41Cross scope privileges, which is empty. Design access, which is empty. And restricted caller access privileges, which is also empty. So not a whole lot going on there yet. But what we're going to do is we're going to create something, and we're going to create a new table for this application. Now, again, this looks a lot different from the way that we did things back in just the regular ServiceNow instance when we created a new table.

9:11Instead of navigating to system definition tables, what we're doing is it asks us to choose this thing called a file type, basically just asking us what is it we're trying to create, right? Are we trying to create a table or a UI policy, or what are we doing? So in our case, notice that there's all of these categories over here on the left-hand side. And the one that we're interested in when we want to create a table is the data category. So if we click on this, what you'll see is that it gives you some options, right?

9:41So you can create a form. You can create a form section. You can create a many-to-many definition. That's something that can save you a lot of time. We'll maybe talk about that in a little bit more detail later. A relationship or a table, and you can also see that there's this table column thing here. We're going to click on table and say continue. And this is going to look a little bit familiar but in kind of a weird, you know, kind of a weird setting. So you can see that not a whole lot's changed here about the table form, but it's inside this new, you know, little tabbed window here that ServiceNow gives us.

10:18So, again, this is just kind of the idea here is it's bringing it all together inside this single kind of centralized tool that makes it so that we don't have to navigate around to all of the different modules when we need them. All right, so for the label here, let's try and recreate a little bit the visitor check-in application that we were working toward in previous skills. So what we're going to do here is we're just going to call this something like visitor check-in. All right, and that's going to generate a name here, and notice that the name is scoped, right?

10:53Remember that we selected this as a scoped application, and so, you know, it's not this you visitor check-in thing. It's actually scoped because it's got this, you know, X underscore and the whole prefix. Now, if you want to rename this a little bit to make it more readable, you can absolutely do that. But, you know, there is some advantage to keeping it, you know, to keeping, like, the name of the app and then the name of the table all in here, right? It makes it easier to tell, like, if you're writing, let's say, a fixed script or something like that, and you're trying to use a glide record to access this table, it makes it easier to tell, oh, yeah, that's right.

11:31This is in another scope. I won't be able to do that unless I also set this or that thing up, okay? So there is an advantage there. I'm just going to leave it the way that it is. Notice that the application is my first app, right? So it's scoped to that, all right, the application that we're currently working in, which is what we wanted. And then for the columns, what we're going to do is we're just going to add those same columns that we had before. So we're going to say something like, you know, visitor name, all right? This is going to be a string here, of course.

12:02So we'll select that, max length. Visitors have some pretty long names sometimes, so we'll do 100 characters. And then we'll do something like checked in by, just kind of the same thing as what we did before. For the type, this is going to be a reference. And we're going to have this be a reference to the user table, which, as you may recall, we are allowed to do in scoped applications because the user table is in the global scope. And our applications, at least in terms of references, are typically allowed to reach into the global scope to reference some of the tables that are there, such as the user table, okay?

12:41As we also saw, you're not allowed to do the opposite typically, right? You're not typically allowed to create a reference from, say, the global scope into a scoped application just in case, you know, the admin uninstalls that application and you now have broken links, right? So anyway, we have visitor name and checked in by. The last thing we're going to do here is we're going to say here we'll add a purpose of visit. And maybe we'll turn this one into a choice eventually, but for now we're just going to have that be a string.

13:11And because there's probably some lengthy explanations here, we'll have this one be 500 characters max length. And now we're going to say submit, all right? So let's just wait for this thing to finish. It's creating that table in our app behind the scenes. Just ignore that weird little error there. I have no idea what that's about. And now what we're going to see is if we close this tab, all right, let's just go back in here and we're going to hit refresh because it doesn't update the files automatically.

13:41What we'll see is that instead of four application files, we now have a staggering 26 files in our application. So what on earth is that about? Well, this has to do with the fact that when you create a new table, there are a lot of things that go along with it, right? So there's dictionary entries, which help kind of define the columns of the table, right? So we see this purpose of visit dictionary entry. There's access control rules that are created as a result, right? Like we just saw recently, you know, we want access control rules around creating, reading, writing, and deleting data in this table.

14:19There's specific field labels. So feel free to kind of browse through all those because, you know, it's pretty interesting to see. All right, so that's how we add a new table to our application. And again, it is a scoped application. So this is a little bit different than what we've been doing in most of our demos. But the next thing that we're going to do is we're going to see how we can add a few other pieces to this application.

0:00All right, well, now that we've created our application and added a table to it, the next thing that I wanna do is show you how you can add specific files to this, right? And what the effects are down here. So we already saw that adding a table added quite a few new files, right? 22 to be exact here. And, you know, this is really, it's still just a way of keeping track of all of the things that are related to this application in one place.

0:32All right, so let's scroll through this. And I'm curious, do you think that there is, you know, that there are things like forms or modules that were created for this? And there absolutely are, right? As you can see, there's this visitor check-ins module, which is very similar to what we saw back here in the global scope when we created that visitor check-ins module here, right? So basically, having this as part of our application means that if we were to publish this application and then someone were to install it, it would automatically add all of these things, including the modules to that person's or that organization's ServiceNow instance.

1:12So here's what we're gonna do. We're gonna go and say create, and we're gonna add something else to this application. Specifically, we're gonna create a UI policy that will do something very similar to what we saw with the ACLs. What it's gonna do is it's going to make the fields read only for visitor check-ins when the visitor check-in has been created, okay? So here's what this is gonna look like. And by the way, this is not as secure as what we saw with access control rules, but I really just wanna show you how you can add things like UI policies here.

1:45So we're gonna search for UI policy. Oops, UI policy, there we go. And we're gonna scroll down past catalog UI policy. We don't really care about those. Screen UI policy, we just want regular old UI policy here. And we're gonna say continue. And by the way, just the fact that UI policy brought up so many different file types, that should alert you to just how much, just how many options you have in this ServiceNow Studio tool. So anyway, we're gonna say continue. And what you'll see is, again, something very familiar.

2:17This is just the same old UI policy creation form that we saw back in ServiceNow, but it's displayed to us in a much more organized and kind of centralized way, right? After we create this UI policy and submit it, it's just gonna take us right back to our application instead of making us wonder where to go next. So what we're gonna do is we're gonna select our table and notice that because of the application scoping, right? Because we're creating this as a scoped application, the only option here is our visitor check-in table that we created, which incidentally is the one we wanted anyway.

2:54So for the short description here, we'll say something like make read-only. Or here, we'll say something like make created check-ins read-only. Kind of a weird name, but we'll just leave it there. And now what we're gonna do is we're gonna say when to apply. And we could use a script here to check whether this record is new and make those fields read-only. Another thing that I think might do the same thing, and I have to actually test this out, it's kind of a funny thing because it's hard to actually find information about these things like in the forums, so we're just gonna test this out here.

3:30I think you can do this by saying created is empty, all right? Because again, if it hasn't been created yet, then the created field should be empty. Let's just see if that works. If not, we'll come back and we'll modify this and make it a script instead, and that'll be totally fine. But now we're gonna say submit, okay? And let's just scroll back down, and we're gonna create some UI policy actions. We're basically just gonna make all of the fields on this form read-only. So here's what that's gonna look like. We're just gonna say field name. This will be the visitor name.

4:01We're gonna say read-only, true, all right? And then we're gonna say submit, and we'll do the same thing now for some of the other ones. So oops, let's just go back there. Oh, it opened a new tab for this, which is kind of interesting. So we can just close that tab, come back here, and you do have to hit refresh, actually, in order to see it. The interface is a little bit clumsy in some aspects, but anyway, there we go. And sure enough, we see that that UI policy action is back. And we're gonna say new and create another one now.

4:32So this is gonna be field name. We'll do purpose of visit. We'll set that one to read-only, all right? That's gonna be true there. And we'll say submit, and again, that's gonna do that same thing. So we'll just close that, and then we'll come back down here, say new, and we're gonna add another one, which will be that the checked-in by, that's going to be read-only as well, okay? So we'll say submit for that, and we can close this, and then let's just hit refresh one more time here, and close that window that keeps opening on the left-hand side.

5:05Sure enough, we see that all of these things here, checked-in by, visitor name, purpose of visit, those all are set to read-only when this UI policy applies, okay? Oh, and actually, we want this to be the opposite. I got that wrong. That should be created is not empty, if this even works, right, which we will try out, okay? So we're gonna say update now, and this brings us to another question, and that is now that we've created a table and a UI policy, how do we actually test these things, right? Because as we saw, you know, back here, we have this visitor check-ins thing, but that's from the previous time, that's from like the previous demonstration that we did when we were demonstrating access control rules.

5:47This is the visitor check-ins table in the global scope. So because we've created this scoped application, how do we actually test it? Well, first, what we have to do is we have to publish it, so just like what we saw with flows, how we had to, you know, publish those, or decision tables, how we had to publish those, we also have to publish apps from the ServiceNow Studio when we wanna actually try them out in their, you know, modified form, right?

6:17Whatever changes we've made to that, if we wanna actually see those in ServiceNow and click through them ourselves, we've gotta publish it. So here's what we're gonna do. We're gonna click publish, all right? What that's gonna do is that's gonna bring up this little modal. It's gonna ask us what we want the new version to be. All right, now I should mention that in case you haven't worked with this specific type of versioning before, this is called semver, right? Semantic versioning. That's just kind of a shortened version of saying that, but basically what each number in here refers to is how big the changes are that you're publishing, right?

6:51So this little number here is what's referred to as the patch version, right? So these are just little updates that are meant to do like small bug fixes, things like that. These are minor version updates, where perhaps new features are released, but it's not actually gonna break anything. And then this is the major version, which typically means that it will break things if you don't, if whoever's using this thing doesn't make some changes, okay?

7:21So an example of this, I used to be a React developer, and so when React went from version 16 to version 17, that was a major version update, and in order to update from React 16 to React 17, you couldn't just update the library you were using. You actually had to change your code in order to make your code base abide by the new usage of that library. All right, so anyway, this would probably be a minor version update here, because we've added a table and some UI policies and stuff like that, but we're just gonna leave it at 1.0.1, and we'll just say Publish.

8:03And you can add release notes too if you wanted to specifically say what changed there. All right, so as you can see, it's publishing the app. This is typically a pretty quick process, at least for small applications like what we have here. And once we're done, we're gonna say, well, done. And now you might be wondering, how do we go access this thing? Well, typically, once you publish it, you should be able to just see it directly in your app. However, I actually made kind of a weird mistake that in a way I'm glad I made, because it shows how cross-application scopes or naming things the same thing can be a bad idea.

8:40Let me show you what I mean. If we try and search for visitor check-ins now, and here, let's just hit Refresh there. If we try and search for visitor check-ins now, what you're gonna see is that there's actually two visitor check-ins here. One of those is the old one, and the other one is the new one. So how on earth did this end up here? Well, that's because this application menu, visitor check-in, when we created this new visitor check-ins table and said that we wanted it to create a module and application menu to go along with it, that actually just selected the global visitor check-in menu which is not what we want.

9:19So what we're gonna do instead is we're gonna go back here and we're going to say that we wanna create a new application menu. So we're gonna say application menu, all right, and we're gonna select sysapp application, not sysui application, and say Continue. And what we're gonna do here is we're gonna give this the title of, let's see here, we'll give it the title of My First Application, or we'll just call it My First App. We get to select the roles that we'll be able to view this, and I'm just gonna leave that blank because we'll want all of users to be able to view this, all right, at least for now.

9:57Just make it a little easier. And we're gonna say Submit which will create that new application menu, and now all we have to do is go back to our visitor check-ins module and reassign it to that new app, right? So we see application menu. We're gonna change this. This is currently, if you look at this, if you type it in again, you'll see that that's actually the visitor check-in global menu that we created. We don't want that. We want My First App, and we're gonna select that one here and click Update, and now that we've done that, here's what we're gonna do.

10:31We're gonna have to come back and publish our app again, and notice that I have hopped forward a few versions because I had to test that out and figure out what was going on. There's a lot that editing hides here. So we're gonna say Publish, and that's going to publish our app once more, and now what we'll see, if we click Done and go back here, and we'll just hit Refresh for good measure, is if we now search for My First App, there it is. You can see My First App, and then it has visitor check-ins underneath it, so we're gonna select this, and sure enough, we see that this has, well, nothing in it.

11:05So let's go and create something. We're gonna click New here. We're just gonna say Visitor Name. We'll say something like, I don't know, Louis Armstrong. Just listening to Louis Armstrong recently, so that's probably why that popped in my head. Checked in by, we're just gonna choose ourselves here. For purpose of visit, we'll say something like doing a show, all right, and we're gonna say Submit there, all right, and that will create a new visitor check-in here in our app module, okay? Now, just to avoid further confusion, what I'm actually gonna do after that little hiccup is I'm gonna go in and actually deactivate the module and application from our previous access control examples, just so that that doesn't interfere with this in the future.

11:49I doubt it will, but just to avoid confusion, here's what we're gonna do. We're gonna go to Favorites. We're gonna go to System Definition Modules. We're gonna go to Visitor Check-ins with the U Visitor Check-in table here, and we're gonna set that to inactive, and actually, we need to click here to edit this record because it's in a different scope than we're in currently. It's in the global scope, and we were just in the application scope, so now we're gonna just come down here. We're gonna deactivate it by unchecking that active box. We're gonna say Update, and now what we should see is if we search for Visitor Check-ins, that's the only thing that comes up for it now, which is exactly what we want.

12:28So anyway, hopefully this has helped you to understand not only how we can add new things to our app, but also how we can publish it and then test it in our ServiceNow instance.

0:00All right. Well, now that we've seen the basics of creating an application, adding simple things to it, and then publishing and testing the application. The last thing that I want to do here before we move on to a challenge is I want to walk you through the main categories and different options that appear when you open up this create file window here, right? You know, as we've already seen, a lot of the things in here are things that we've been able to access from the main service now interface, right?

0:31Things like tables, UI policies, et cetera. But the advantage of doing them through the service now studio is that they're arranged in a way that makes a lot more sense, right? So in other words, you know, as we've seen, if you want to do something related to adding data, right? If you want to change something related to your applications, data needs, you just go to this data section. And that has basically a pretty comprehensive list of all of the different possibilities there. Okay. And so what I want to do is just like what I did with the flow designer, I want to walk you through each of these sections and kind of talk about what each one is actually about, right?

1:11So this will just kind of orient you in the future when you want to add different features to your application so that you'll know exactly what you need to do and where to find it. So the first thing here is, you know, obviously there's this recent menu, which shows everything that we've recently touched. That can be very useful when you're doing more repetitive tasks, like if you're creating multiple tables or if you're creating multiple UI policies, right? Cause they'll all show up in there. And if you're looking to just have a complete list of everything that's available, I would, I would not really ever recommend using this just because there's so many things in there.

1:45As you can see, I've been scrolling furiously and I'm still only at F. And so, you know, I have never, ever used this all section, but I'd imagine it's useful for, for some people. I don't know. Um, but anyway, the next one down is automation. And as you can see, this contains pretty much all of the main pieces that we saw in the flow designer, right? So we have action, we have activity definition. This is something that's used for playbooks, which we haven't really seen, but um, that's just what that's for a connection and credential aliases, data streams, decision tables, email templates flows, right?

2:21We know what that one is. Notifications, playbooks, sub flows. And so basically anything that you want to automate here, um, that is at least in a drag and drop fashion. These are mostly drag and drop automation things, right? That you'll, you'll see in the flow designer. Anything like that is going to be under this automation category. And the interesting thing here is if you open one of these up, right? So if you choose flow, let's say, and say, continue, then what that's actually going to do is that's going to open up the full flow editor, right?

2:52Same thing as what we saw in the flow designer. All right, there we go. It's going to open that right up here in this tab, but instead of it being in, you know, the workflow studio that we saw earlier, it's in service now studio. Again, those are confusingly similar names, but the point here is that it's the same interface, just like what we've seen with filling out basic forms, but it's, you know, it's in a different setting, which makes it much easier to kind of work with, right? So what else do we have here? Um, the next thing is client development.

3:25This one's kind of interesting because basically this has to do with anything that's going to be on the client side, right? So this is where you'll find things like UI policies, UI scripts, a client script you just saw in there. There we go. Um, and a lot of other things that we haven't really talked about. So again, any kind of client side customization that you're trying to do, this is where you're going to find that now content. This is kind of interesting and also not something that we've really talked about, but if you're, um, you know, let's say that you're trying to add a blog to your service now site.

4:00All right. So as we've seen, if you open up the, uh, service now service portal, right, which is kind of like the, um, oops, let me try serving for searching for that. There we go. Service portal home, which is kind of like the, the public facing, uh, interface of your service. Now instance, uh, in most cases, well, this gives you the ability to, you know, add things like if you wanted to add a blog to this or something like that, you could definitely do that. And specifying the content for that blog, that would be what you could do here, right?

4:31So you could use, you know, obviously audio, probably not going to use that. Um, images, right? You could have static content, you could have dynamic content, kind of depends on what you want to do with that. But basically any kind of content needs, uh, this is where you're going to come for that data. This is where you define your, uh, applications data structure, right? So the tables, the table columns, the relationships between tables, right? Many to many definitions. Um, the forms for your tables, all of that's going to be in this section here.

5:04What else do we have here? Integrations inbound and integrations outbound. Those are both very important because what they allow you to do is, uh, kind of deal with third parties that are, that you either want to get data from or that you want to send data to typically. So as you can see, integrations inbound, this includes things like data import and all of its related, uh, aspects like data sources, scheduled data imports, transform maps, things like that. Um, for outbound integrations, this includes things more like, you know, exporting data, but also includes things like rest messages, which are considered outbound integrations.

5:44Okay. When your application, you know, when service now actually sends a network request to some external party as the result of something happening. Okay. Uh, what else do we have here? Mid server. Um, we haven't really talked too much about that, so I'm just going to leave that one there. Mobile. A lot of companies aren't really using this too much anymore because this, um, you know, this is more like when someone's using service now on their phone, as it happens, while that can be helpful while you're on the go, a lot of people just kind of prefer to use service now through the main interface.

6:15So I don't know if you want to configure those things like the different screens for the mobile experience or, you know, different lists, different views. Uh, you can do that. That's where you would come for this. We haven't really talked about that too much here, but, um, what else? Natural language understanding. This is kind of an interesting and very specific category. Um, you know, and after all of the stuff that we've seen with generative AI integration, uh, this is kind of another option for that. I would say kind of a less sophisticated option perhaps, but anyway, feel free to explore that if you want, um, properties, this is actually something we haven't really talked about yet, but, uh, when you create an application, you're typically going to want to leave certain aspects of that application open to the user, right?

7:01Or open to the admin. That's actually going to be installing your application into their service now instance. So for example, right in our case here, we've seen how we can create, you know, let's say a custom action that will communicate with the open AI API, but that requires the open AI API key, which is not something you're going to want to publish along with your application. So in other words, you're going to want the admin to actually have to pass in their own open AI API key in order to use your application.

7:34And that's, you know, system properties are how you would leave that open, right? Basically what that does is that just gives the admin who's installing your application, a form that they have to fill out. And then those properties are accessible from inside scripts and other parts of your, your app. So anyway, we'll talk about those in a little bit more detail later, perhaps, uh, reporting. Haven't really talked a whole lot about that, but this just allows you to define lots of things to do with reports. So you can define specifically reports or, uh, scheduled emails for when you want to send out those reports, ranges, metric definitions, and even things like, uh, you can define the colors that show up on charts.

8:12So if you have specific organizational colors, right, then you can incorporate those. Uh, what else schedules? We talked about those a little bit earlier when we were talking about schedule jobs. So that's where you could define those, uh, security. So this is where you can configure things like access control rules and roles and also public pages, which are just pages that anyone can see. Um, what else server development? So this is where you can define, you know, server side logic. This is kind of the server side, uh, counterpart to client development, as you can see.

8:48So, you know, you see that there's things in here like business rules, data policies, events. Um, what else? Fixed scripts, scheduled scripts, basically anything that's going to happen on the server side is going to be under this category. And, um, the last thing here is user interface. And this is basically just individual pieces of user interfaces that you can define. So you can define things like lists or list controls or, uh, maps or modules or portals or related lists.

9:18There's lots of things you can do in here. Um, so feel free to kind of explore that. And the last thing is other, this is, I think just things that didn't really fit into, uh, some of the other categories. All right. So, um, you know, if you're after something very specific, that's not in the above categories. This is apparently where you would come to find that. So, uh, anyway, hopefully that's kind of oriented you with regards to where everything is and, and how the service now studio organizes all the different file types versus how they're organized in the main service now interface.

9:54And again, hopefully this just helps you find things when you need them.

0:00Alright, well now it's time for a challenge and in this challenge your responsibility is just going to be to add another file to this application that we've been working on in this skill and Your challenge essentially is going to be to create a flow that will be triggered when a new visitor check-in is created That will get approval from someone you can choose who you want this to be For actually letting the visitor into the building all right, so the idea here is that a visitor check-in would be created when you know a visitor comes up to the front desk and You know whoever's working at the front desk creates one of these But then we'd want to have someone actually approve this just so that there's a record of who said okay Let this person in right so That's gonna be your challenge and um after that after that approval step Maybe you can add another thing in the in the flow that just logs something out to the console Or maybe you want to generate like a badge number or a badge ID or a temporary ID or something like that for the user You don't have to do this, but that's just kind of an extra little thing if you want to Give it a try so that is your challenge So feel free to give this maybe five to ten minutes to complete and once you've given it a try you can move on to

1:16The next video where I'll walk you through the solution so best of luck, and I'll see you there

0:00All right. Well, hopefully you gave this challenge a try. So let's take a look at the solution. So the first thing you had to do here was go to create in the application and we wanted to add a new automation file and specifically we wanted to add a new flow. Now, as I showed you, this is basically going to use the interface that we've been using back in the regular service. Now, you know, experience for creating a new flow. Um, so there's not really going to be too many surprises here.

0:31It's just going to be interesting to see what's actually created behind the scenes in our applications file. So let's go back to new flow. We're going to call this something like get visitor approval. All right. And oops, I didn't mean to do that. Let's just click build flow here and there we have it. So let's start off by adding a trigger. We want this flow to be triggered when a new record is created in the visitor approval table. So we're going to select that table from here. All right, we'll select this table.

1:04But the thing to notice is that a lot of the other tables are actually accessible to us here as well. So this is kind of an interesting exception to, you know, the, the typical situation that I described earlier when we were talking about application scope, because as I mentioned earlier, typically you're not going to want to, you know, be able to cross the lines between applications. So if the, if we have the global scope and then we have our applications in here, a, b and c, well, typically we're not going to want, let's say tables in application a to be able to reference tables in application B. And you know, uh, we're not going to want to be able to create UI policies and application C that reference tables and application a, but, um, in a way, uh, flows at least flow triggers are kind of an exception to this because they're a little bit, they're a little bit less serious if an application gets uninstalled, right?

2:03In other words, if we create a flow here, let me just undo some of that there. If we create a flow in application B that's triggered by, you know, something getting created in a table in application a, then it's not the end of the world. If application a gets removed because all that'll happen is that that flow just won't ever get triggered again. Right? So it's a little bit of a lower commitment situation, if you will. Um, then doing things like actually creating references or, uh, you know, creating scripts that are able to load data from other applications, things like that. So, um, anyway, with that in mind, let's just click done. And then for add an action, what we're going to do is we're going to click action.

2:51We're going to say that we want to get approval. Oops. Uh, let me try that again. I'm just going to type approval. Oh, ask for approval. Okay. I always forget the name of these things. Um, that would seem oddly specific or like a slightly different, uh, phrase than I would have used, right? Get approval versus ask for approval. Anyway, here's what we're going to do next. Um, for the record, we're just going to use that, uh, trigger from the record. So we're going to say visitor check-in record, right? The approval reason of something like, uh, need the okay to let this person in, uh, into the building we'll say, all right.

3:32And then we're just going to skip the rest and we'll say approve when, and we're just going to choose, um, anyone approves and we'll S we'll pick a specific user here. So we'll just do a system administrator. Um, although obviously you might want to have someone else or have this calculated dynamically, things like that. So we're going to say done here. And, um, well, once we've gotten approval, we're just going to say if the approval was successful. So if approval state is approved, all right, so we'll say if approved is what we'll say there, then what we're going to do is we're going to say done and we're going to add an action here, uh, which will be, we're just going to log something out to the console, uh, basically saying that this user was let in.

4:14So we're just going to say something like let, and then we'll have the visitor check-in record here. And we're going to actually get the user, um, or that the name from it, the visitor name, that is, we'll say, let this person in. All right. And then we'll say done. Okay. So let's activate this flow. We're going to say activate. And then, um, you know, just like what we saw previously, uh, if we now go back to our app, which we'll see, um, by the way, if we hit refresh that there should be some extra things that were added to this, we now have 45 files associated with this application.

4:52Um, whereas before I think it was 34 and sure enough, we see that we have flows and also things, uh, called flow blocks, which are basically just pieces. That's kind of one of the interesting things, or that's what I originally really liked about working with service. Now studio, um, at least at first is, uh, it gives you the ability to see what's actually going on behind the scenes when you use those other interfaces, right? So when you create a new table, as we saw that created a lot of records behind the scenes and same thing with flows, right? You get to see what the actual pieces are that are being created behind the scenes. Anyway, um, now that we've created that, what we're going to do is we're just going to say publish, right?

5:32Now that we've added that flow to our application, we're going to say publish. We have the new version there. And, um, we're just going to wait for that to finish here. Typically goes pretty quick. Then we're going to say done. And now if everything is set up correctly, what we should be able to do is we should see that, um, you know, let's just, uh, hit refresh here on the visitor check-ins page. What we're going to do is we're going to say new for visitor name here. Now that our company seems to have, you know, uh, famous jazz artists coming in, let's maybe, uh, we'll say, uh, John Coltrane. All right.

6:07And it will say checked in by system administrator. And actually I realized after I created the last one with Louis Armstrong that I missed a, uh, a golden opportunity here for the purpose of visit. So I'm just going to put it on John Coltrane, even though the quote itself is typically attributed to Louis Armstrong. We're going to say, if you got to ask, you'll never know. This is apparently what Louis Armstrong said when he was asked, uh, his, what his definition of jazz was. So let's just click submit and sure enough, we see that that was created.

6:38So let's just double check if this created on approval. All right. Um, we should be able to go to my approvals now. Let's just open that up here. And sure enough, we see that there's this requested, uh, approval that says need the, okay, to let this person into the building. We can see visitor check-in. Um, that's what we're approving here. And so if we say approve, we're going to go to the logs. So we'll say system logs. All right. Uh, system log is what I wanted there. Let's just scroll down and go to, um, all.

7:09And now what we're looking for here is, and sure enough, there it is. All right. So anyway, um, that is the solution to the challenge. So hopefully this helped you to, uh, practice, you know, adding new pieces to an application and also helped you to review the basic process of publishing and then testing the app.