In this tutorial Ray Deck demonstrates Xano’s new dependency‑tracking feature within the StateChange workspace. He walks through a real‑world scenario—converting Zoom office‑hours recordings into archive assets—and shows how functions and tasks are linked in a hierarchical tree. The presenter explains how to view both the functions that call a given function (direct references) and the upstream ancestor functions that ultimately depend on it. By navigating the function stack view, users can see which endpoints, functions, or add‑ons a function relies on, and which tasks or other functions would be affected if the function were removed or altered. The video highlights the distinction that tasks can depend on functions, but functions never depend on tasks, and emphasizes how this visibility helps developers manage large Xano projects, avoid breaking changes, and make smarter code‑management decisions.
Chapters
Xano systems can get pretty complicated. Right now we're looking at the state change workspace in Xano, and you can sort of see one of the tasks we've got going on here, right, which is about, uh, you know, converting, uh, videos, uh, that have been recorded through Zoom, uh, for office hours, what have you, to turn them into things that can be part of our archives, both for our vault and for our assistant, what have you. Now the thing is, like, this task is actually made up of functions. Function— a bunch of functions are going to go get called. And I can go click into that, you know, click into one of them, and then I can see my unmarker_meetings, right? And the idea then is that I can, you know, sort of keep on, you know, going down the tree. Like, I can see this thing is being called, right, by the, by that particular task, but then it has all of these different functions that are dependent on it. And that's basically a new feature here that we've got inside StateChange, being able to see both what functions your, your function or your task or whatever, what it depends on, as well as what it's being called by. There are sort of two parts to this. So the first being you will see who uses this particular function. So when you're analyzing your functions, you know, like you're going through your function list or what have you, and you want to sort of see your functions and like what they— and who manages them, you're able to see the direct references for them when you look at them through, you know, just through the list or what have you of functions that are available to you, right? How many endpoints and how many functions might use it, whatever, right? All these things. But the other thing you do is you can actually see how far up the tree they are used. So if I were to click into this, I can see not only who immediately calls it— that's the same thing that like Xano gives you for free— but also what ancestor functions, basically who calls those functions, right, up the tree. So you can find out eventually, hey, here are these other tasks that also depend on this particular function. So if you were to remove this function, this is all the stuff that would explode for example, or if you change its functionality, who else has dependencies on it. And you can see that it doesn't depend on anything else. Contrast that with this function here, analyzing unmarked meetings, which is both, which is used just by this one task, the task is the one thing that's calling it. And then you have all of these functions that go on underneath. The idea is you're going to start to have this web of dependencies of who's using what inside your Xano. And this starts to put the picture together for you of being able to see just like by going into your function stack view, Being able to understand who, you know, for any given function, who's using it, what it in turn depends on, that so you can understand like how, how this whole network works. You'll notice that when you're going down the dependencies, the only thing that given function can depend on is gonna be some combination of functions and add-ons, right? Because those are the only things you can include in other functions or tasks or whatever. Whereas the things that you can be referred to by will be all the things, right? Like a task can depend on a function, but a function never depends on task, that kind of business. So the idea here is that you get better visibility being able to look up and down and be able to see the whole picture, both in terms of a list of things that are, that are calling your particular function, and also being able to either see the tree of dependencies, like who's calling what and then what their internal dependencies are, or probably the way I use it more is just to look at the list and being able to see all these different functions that are called either directly by this particular function stack, or they're called by the functions they call, or called by the functions that those functions call, etc., all the way down. For when you're building a large Xano instance, this is going to become really handy for you to get a better understanding, right, of what depends on what. And so you can be making smarter decisions about how to be managing your Xano code.
