My Top 5 n8n Workflow Tips to Save You HOURS on Client Projects

0:00Hello legends. In this video, I'm going to show you my five-step process of how to build out NA workflows. This is the exact process I use when I'm working with clients. This is exactly how I extract the right information so I know what they want to build, how I plan the workflow, how I build it, how I add logging, and then finally, how I ensure a clean handover. So, by watching this video and following this process, you'll feel confident and capable of handling your very first n project. Okay, let's get into it. Okay, so these are the five steps we have. How do you plan a

0:28workflow? How do you add logging to a workflow? And why would you want to add logging? How do you test your workflow? How do you deliver in stages? This is really cool. And then finally, how do you hand over your workflow to the client? So this stage one is actually really interesting and this is a very big learning that I had. I would typically wait and deliver my workflow all at once at the very end. I've never done service work before, so this is I had to learn this the hard way. What is better to do is to actually figure out a plan where you can build the workflow in

0:54chunks and then give those chunks one by one to the client. Like if you're building out an AI agent, which we are in this in this demo, you would build out the primary agent. You'd give it to your client to test and play around with. Once you get their feedback, you move on to the second stage. You apply any of their feedback as well. This building in stages is super cool. It also gives the client something like immediately back. So if you're working on a an 8week project, if you deliver something each week, it keeps them engaged. It shows that there is progress and it also keeps you calibrated because

1:22they give you feedback and they say either thumbs up, you're doing the right thing or like thumbs down, you need to turn left, not right. So that's actually really really cool. Now for now, I actually want to start off with going to step number one. How do you plan out the workflow? So what I find when I work with clients, a lot of clients typically tell you at a very high level what they

1:41want to get. They're not very specific. So they'll say something like, "Hey, I want an AI agent that can monitor my Gmail inbox." This is like the level of detail that they give you. If you're first starting with projects, typically what you would do then is just take what they say at face value and go to nan and build something like this. It's a Gmail

1:58trigger node that reads all the emails. You put each email as context into your AI agent. The agent generates a response and then you apply that response back into that Gmail ticket. So at a high level, you technically did build out an AI agent to monitor the Gmail inbox. But after you give this to the client, they're going to use it and they're going to say, "Hey, it's actually not doing the stuff that I was expecting it to do." And that difference that like what they're expecting it to do is actually then a conversation that you have afterwards. They give you that feedback and then you go back to the

2:28drawing board and then you rebuild the agent. So what the point of this first part is is before you build anything, you actually ask the client a couple of questions. So the three questions that I would ask are number one, what happens before this workflow? like so this process that we're building out right now what's happening before what triggers it what kind of information should I be looking at before I'm building out this specific workflow number two the question I would ask is what's your existing process to handle this workflow what are you currently doing now who's doing it how many people are involved what tools do you use like

3:00tell me your exact process and then the third question I would ask is what happens after this workflow so after we do this are there any other tools that we have to interact with and kind of send information across to do we have to notify someone of something. Do I have to log some information somewhere? So, by asking not, you don't have to ask all those three questions, but if you ask a combination of those three questions, you typically unzip the client and they'll tell you everything. So, your purpose at this stage when you're asking these questions is to actually gather information. They're asking you to

3:28automate a process for them. They're not asking you to design a process and then rewrite how they run their business. They're just asking you to like, "Hey, I have this thing that I do. can you please translate it into nan language? So it's okay to ask them questions. If anything, it's actually expected you ask them questions, especially if they don't give you a lot of context. And it's okay for you to ask for processes. So you can actually just say, what's your current process now? Do you have standard operating procedures, SOPs? Do you have team members that I can actually speak with to learn more about how they handle

3:58this thing that you want me to automate? So there's a bunch of different questions that you can ask. So in this stage, let's say the client says, "Hey, I need an AI agent to monitor my Gmail inbox." A sample question you could ask is why do customers email you? So this is a very basic question and it's a very straightforward question as well and their response could be something like well it's not just customers that will email me it's actually suppliers too. So I run a plumbing business and typically customers will contact me for new quotes for jobs and also to check on the status of an existing job and then suppliers

4:28would contact me to either update on delivery time frame so when I may be expecting some of my plumbing supplies to arrive or to chase up payment. So if I owe them some money for a bill that they sent me. So then what you could start doing with this information is actually start building out a list of responsibilities for the agent. So one of the things that you'll need to do is actually figure out like what does this agent do? What is the prompt that I need to create? So by asking this question, we already know that the client has two types of customers or two types of users

4:54that will email them. A customer or a where is it? A supplier. And they've given us two different things that they'll be contacting us about. So then what you could do is go across to something like Google sheet and just start mapping out all the different variables that you know for the workflow. So for example, you got two different types of users where a user might get get in touch with us about a new quote or about a job status and then a supplier about a delivery update or a payment. So then from here you can go and add an a new tab that's called processes for example. And then you can

5:22just keep speaking with your client and say hey okay for customers when they message about a new quote what's the process? What do you currently do? and they might say, "Hey, we have this CRM where we log every interaction into there. We have this price list in Google in Google Sheets that we want to pull the price from." And then, yeah, we just respond in that email in a nice and friendly way. And you say, "Okay, for job statuses, they might also say, "Yep, we log everything in our CRM. Here's the access." Then all we really want to do is just look at this specific field in

5:49the CRM that's next to the customer. And then give them the information from there. And if there is no field there, maybe we just like send me a message. Do human in the loop. send me a message, I'll find out what's happening and I'll respond back via SMS and then you can just send that response back into Gmail. So the client would always give you the process that they follow. Or the cool thing is sometimes they'll say like, oh, what's really possible? Like you can send SMSs. Cool. Let's actually adjust the workflow. So it's it's not very often that you have to make up a workflow from scratch. You typically

6:18just get that information straight from the client. Now, the next cool thing that happens is that when you ask these questions in that initial discovery stage with your client, you actually start building out the scope of work for your project. You say, "Hey, cool. I can build you this AI agent. It's going to be able to speak with customers and suppliers. It's going to handle these four request types, and here's the processes that it's going to replicate, and here's all the systems that's going to integrate with." So, when you're thinking about even pricing, how do you actually price your workflows? Now that you understand more about the system,

6:47you can actually understand more about how long it's going to take you to build. And then obviously because you know all this information, the client's going to get exactly what they want. So at this stage, you can actually just keep going with building out your workflow. We come back into our core AI agent build over here and we understand that we have a CRM. So maybe now every email that comes in, we actually check it against the CRM to see the customer type. So we might want to understand if

7:10it's a customer or if it's a a supplier. And then maybe we split off and we have two different agents that are handling both workflows. Maybe one agent is specifically for customers and it has the customer price list, the customer CRM and just has a prompt around working with customers. And then the second agent is something that works with suppliers. Again, a whole different knowledge base, a whole different set of processes. But assuming we just kind of keep things very simple, I'm not going to be connecting a CRM into here. But let's say we just try and mimic what a CRM would do by using a Google sheet

7:42node. So the Google sheet node would then we get the email address from the actual sender. We plug it into the Google sheet node. We bring that context into here and then we might have an if node to actually split off different routes for different agents. But at this stage we actually see we start building out the agent a little bit more make it

7:58a bit more of a sophisticated system. Now another way that I do this step as well is sometimes I'll give my client a um an Excel sheet like this and I'll say hey list down all the things that you want this system to do. So if it's an AI agent, if it's some kind of automation tool, list down all the stuff that you wanted to do. And then next to the thing that you list down, link me to your process. If you don't have a process, just write it out over here. Then they'll come into here. They write out all the information. And then you also

8:23want to kn know what you do not do. So what this system will not handle. So in the case of AI agents, maybe your client will say, oh, hey, if it's like the tax emailing us about something, I want to handle that myself. So they might come into here and say, doesn't handle any tax queries. And for a tax query, the fallback is just like forward it to I don't know Slack or you know notify me in some way. So now you actually have a very clear distinct set of like boundaries that you follow when you're building. So this is actually yeah really really cool as well. Once again

8:54you get their processes once you build this out you have a very clear scope of work and you can plan out how you can be building out this agent system for them. Now the next thing I want to speak about is logging. So what do you want to log for? So there's actually multiple different reasons, but let's just start from the very highest level of imagine you build this thing out so good that the client that no human will ever interact with the system ever again. No human's going to go into Gmail. They're never going to be answering everything anything ever again. So you want some

9:21way where you can give your client some kind of some kind of control dials that they can see how this AI agent is handling. So in every team, if you're a manager, you have team members that are below you. So they're on your team. your responsibility is to ensure their quality of work. So how do you do that in an AI agent or into in an automation system that you build? That's by inserting logging into the workflow. The reason that we insert logging and the way that we're going to present this is imagine you watch like a sports game, soccer, baseball, football, anything like this. Typically when they have all

9:52the teams they're they're on a leaderboard and the leaderboard just lists every single team in a league and then each column represents a different attribute of that team. So like number of games played, current standing in the leaderboard, so what position they are. And then maybe it gives you like how many points like if they won a game or if they lost the game week by week. So the way that humans actually process large amounts of data is actually by using lists. So the best way that we can log information is to go back into Excel and actually log it by building out a spreadsheet for this. So going back into

10:22our workflow, the thing that we want to remember here or like the thing the principle that we want to apply for how we log stuff is what are the most important parts of this workflow? Like what are the what are the important stages here? So the way that I would look at this is the first important stage is this Gmail trigger node. This is where we're actually bringing in some kind of data, some like dynamic information into our workflow. This is going to be like the email subject and the email body. The next critical or important stage is the decision of the AI agent. So this could just be like

10:54what kind of reply are we going to apply to this ticket? How do we categorize this ticket? What kind of action are we going to be taking? So the decision of the agent or the AI system and then you have the third part which is the actual action taken in the workflow. So this means you have some kind of data coming into the workflow. That data is being

11:12fed into the agent as custom context. The agent makes a decision i.e. generates a response and then we send that back into the Gmail ticket by using this action node. So there's three key stages here. So if you wanted to map something out here, you actually want to be observing or monitoring those separate key three stages. So let's say the very first thing that you want to log is that data. So the input data is going to be the the email subject and then the actual email body. So that's

11:39that first square on the left hand side. Then we want to be logging what the agent decision was. Decision. And then the final thing we want to log is what was the action taken. So in this case the actual the agent decision you would just log here what's the generated response from the agent. And then typically here it's going to be the exact same thing but there's a there's a bit of nuance here why you would

12:00actually log the Gmail step as well. Okay. So now that we have this defined in our spreadsheet how do we actually log things into here. So you would just go across to your workflow and you would just insert like database nodes. So, we're using Google Sheet here, but if you had Air Table or Superbase, it's the exact same process. Let's just keep using Google Sheets. And you would actually just go into append row and sheet. And then you would just link this up to your spreadsheet. And this thing is going to be doing what's it going to be doing? Log the data. So, the actual object information that we're going to

12:29be using, we log that in this very first part. And then over here, what are we going to be doing as well? How do we actually log it from the AI agent node? Well, the output of the agent, we can put a Google Sheets node over here as well. and we can say append row and sheet once again we're just syncing it up to this sheet and we're going to be assigning it to column C for example this agent decision at this stage is actually um one one workflow pattern that I use is after an AI agent step I always put a code node so I use a code

12:56node to parse the output of the AI agent step I don't like using the the require specific output format with the output parser I don't want to have doubled up on LLM nodes to try and figure out an output I just define it in my prompt and And then I use a code node to pass the output, set some variables and then I can just take those variables from the code node and put them into my Google Sheets node. So in this case I actually I can log both the response from the agent and then also the response into Gmail. But another workflow pattern that I do is I don't like giving my agent any

13:27outward actions. I don't like letting my agent do any like apply any changes to an external system. I don't like it to write some information. I only really like my agents to read information to bring information into context and then use them. And I like my action steps outside of the agent step. So in this case, I would actually log the output of the AI agent step. Then I would put a

13:48Gmail node. So I would do a where is it? Send a message. And then after I send a message, I would log the response here as well. So I would use Google sheet. And we do this because where is the appendroan sheet? So, we're doing this because we want to have a distinct log for each of these key stages. So, now we have this log over here. Actually, let me just zoom out so we can see all this stuff. We have this distinct log for the data that's being input. We have this distinct log for the agent decision and

14:17then a distinct log for the Gmail node. Now, I also separate this out for a for a reason. So, let's say the the client is actually reviewing these. In one sense, they want to review what is actually happening, but they also want to review like when is like if the system stuffs up, how do I get notified? So, you have to also feel like a manager of a team. If something's going wrong on your team, you want to be able to really easy identify if something actually stuffs up so you can catch the issue. If you just leave this system and let's say it doesn't it stops working for some

14:47reason and it doesn't work for an entire week, your client is going to be missing out on what are these request types? They're going to be missing out on new quotes to customers. They're not going to be updating their existing customers. They're going to get pissed off. They're not going to know when delivery is happening. They're going to miss payments and then the supplier is going to be angry with them. So, there's a lot of like risk that's involved with systems breaking down. So, how do you actually install those? Like how do you install a very simple way for your client to be able to see or for yourself

15:12to be able to see if anything is stuffing up? So, going back into our workflow in the exact same process, you have like the main input to input of the data. You have the main agent decision and then you have the main action taken. So typically for a Gmail or like an a third party authenticated node like this, I wouldn't really log anything here. But if I had a web hook trigger, then I would also just validate what's the payload, who's the sender, do I know these guys? If I don't, then you can put a little fail route over here. But what we can do is put a fail route in this

15:42agent step and then a fail route in this Gmail node. So what can fail in the agent step? Well, you might run out of API tokens or OpenAI might go down. So if that happens, something happens in your workflow, the actual entire workflow, the responses to Gmail stop. So what can you do over here? You can have a an error step like this. Let me just clean up the workflow. I'll bring this a little bit higher. So for your error step, the exact same thing. In this case, you're going to be using a

16:07Gmail node to log the error over here. And this error is going to come into either this agent decision. And this could either be the actual response from the agent that was generated, or it could just be a static message. And this thing would just send a static message into your into your spreadsheet saying agent step failed. Something very obvious. Agent step failed. Whatever you want to do. This is really dependent on how you want to build out your spreadsheet. You could also have another column here saying successful or not successful to make it super easy to see these things. And then typically from here you can have another node like a

16:38notifications node. So do you want to put a Slack trigger or a Slack note so you can actually notify a customer? Do you want to give them an SMS via Twilio? So really the world is your oyster over here. But let's just say we want to create a message over here, send a message. And that's going to go across to the client. It's going to notify them if anything is going wrong with the workflow. Now the next place where we might run into some issues is in the Gmail node. So if anything goes wrong over here, for example, Gmail goes down or something happens with your

17:06authentication. Maybe you did the wrong credential type, maybe something expires, the user who's authenticated this method leaves the business, you delete their account for whatever reason, something could happen over here. And the same thing, you just want a failure route over here. So continue using failure route. And then you just take this and you put a failure route over here. And that means again you're

17:26just mapping into this core spreadsheet. And then the action taken could be the response from the agent or once again Gmail node failed. And for failed workflows, we know that we want to just notify the customer as well. And this notification, it depends if you're like managing a lot of these workflows for your clients. If you're overseeing all these workflows, you might actually want to receive this first and just like go through and see what's happening. Could be a very easy fix that you could debug yourself, fix the workflow, get everything back on track. So now, let's just save this. If we just zoom out, we

17:57can see that this workflow is a little bit more sophisticated. So we have our first part where we're logging what information we receive. We have this second database layer that's actually bringing in customer context information for us. We have our core AI agent step with a failure route over here and a success route over here and then our Gmail node with a failure route or a success route as well. So this is actually really cool because now when you go back to this original request that you get from this from your client, hey I want to build an AI agent that can monitor my Gmail inbox. After asking all

18:29these questions, after actually going through this process and understanding what are the responsibilities of the agent, what are the fallback options, what are the processes we need to actually automate over here. When you go to your workflow, it's actually very easy to to justify a more expensive price because you've got to do this thinking for your client. So as you see the original node do we had was like three three nodes for the AI agent that looks into Gmail but now you're having this more productionready sophisticated system. So this actually gives you confidence as well when you're building something out that if anything does go wrong you're going to see it before your

19:01client does and you yeah it's actually just a lot better that way. You don't want your client coming to you. So we just finished speaking about logging and in our case we had logging so we can actually just observe what's happening with the agent and we also had failure logging and failure routes in here. This is actually a double whammy. Now the next thing is about testing. So this is also extremely interesting and a very easy way for you to just like test out the workflow to see if it's working. So in this first stage where you're also like going to your client and saying hey

19:29what are the processes that we need to automate. One thing I didn't say before that I wanted to make it a very distinct thing that you should be seeking out from your clients is give me examples. So after they say to you like hey this this not this specific agent is going to be speaking with customers for new quotes. here's the process that we're following. You could say, "Cool. Send me five example tickets that I can actually read through and understand the process myself." Maybe you as an AI builder, as an NAN, no noode automation builder, you'll be able to see things that your client will not see. You might be able

19:58to see efficiencies that you can apply to the workflow. Or if anything, you could just see what the actual process is and how things are working. So, you just get examples from your clients. And this could be in our case, you know, copy and paste of Gmail chains or they could just download the Gmail extension and just give it to you as well. So over here you have like five examples and then you can just get each of these examples for all these workflows and then you just use these examples and you plug them into your agent. So another thing that you can do when you're

20:25building out your workflow is you might actually want to have some way of testing your workflow. So when you're testing your like when you first build out something like this, as you see our initial the initial thing that we did was we just went to get a Gmail node. If we want to test anything here, we actually have to send some kind of sample ticket into Gmail, wait for it to arrive, wait for it to be picked up by this node, and then actually send across to our AI agent. That process is very inefficient. And also, you don't want to just like put a bunch of test data into

20:52your customer's account. So what you could do is actually use something like a a chat node and then you can just send a message into your workflow. So this could be one node. You could also just use something like a manual trigger. Manual trigger and something like this. But typically what I do when I'm building out my workflows is I will separate this. I know this is going to be my live my production ready trigger that I need to use. And then for testing, depending on what I'm testing with what I'm doing, I will use something like this. So let's just kind of clean things up and say we want to do

21:22manual trigger. And then from here I would get an edit fields node. And then this edit fields node would have the ticket subject and then some value and then the ticket body. Now one thing I suggest for you to do as well is actually you typically want to have this edit fields node at the start of your workflow. So every time you get a workflow you're building it out, you need to test it out some way. So I would typically start with this execute where execute when clicked. In the edit fields node I have the actual variables that

21:48I'm going to be using in that system. And then everything from here onwards is your production ready system. This is the stuff that you're delivering to your client. And then for testing or your production node just plugs into here. So this is going to go into Gmail and just pull out those variables from Gmail, plug them into here. Or you can just manually map them into here, click the workflow and execute it and you run your workflow. So this is actually really good. Now your AI agent node, it's going to be referencing this specific edit fields node. So that means you don't have to chop and change variables and

22:17nodes between testing and between production. You're just mapping it to this specific node and never changes. So now looking back over here, we have these test examples from the customer. So all we need to do, let's just say that they give us one example for each of these. We can just come back into nan. We take this, we just duplicate it four times like this. And then you can just build out a very simple testing station like this inside your nan workflow. We testing the customer tests, so for new quotes and job status, and then supplier tests for delivery info and payment request. And then from the

22:47Excel sheet that we had, we just map in the subject and the body into all of these nodes. And as you go through these and you test them out in your workflow, you would just take the contents of this node, plug them into here, you would click on manual execution, you would run the workflow, look at the output, and if it is acceptable, you would just basically approve this test. So you just change the color to green. And as you go through this, you're just changing everything to green to show that you've tested it out. Um, and then you have full logging of all the tests that

23:12you've done. And you might want to keep some kind of like, you know, you want to note down which execution ID it was. And you might want to be following like up on the actual execution logs as well. So there are different ways that you can actually test your workflow. You can do evaluations now, but this is actually a really solid way to just really quickly test out your workflow against the actual use cases that you get from your client. Okay, so we just looked at a very neat way about how to test your workflow. So we actually asked the client for all right, what are the

23:35processes that we need to follow? Cool. Give us some example tickets. Then we map those tickets directly back into the NAN workflow in that little testing station. Now let's look at how to build out in stages. So this is also very simple to do. So, what you could do is just add a couple more columns to your

23:50initial planning sheet. We're over here. We're listing out all the different tasks that we're going to be automating in our nan workflow. And then we could just decide is you can see you can think to yourself, cool, this customer agent or this customer portion of this AI agent will take me very quick to do and I can actually deliver this on Monday or you know, you typically want to put the date of delivery over here. And you can just take this first section, you could save the workflow, give it to your

24:13client and say, "Cool, like here it is. Here's some test cases that I've done." you can actually just plug it into Gmail and just start testing this thing out and see what kind of feedback you get, what kind of like responses you get, how's it actually fairing in the real world. So then from here after a period of time the client might say to you, hey this some of these requests aren't really working how I think they should

24:30be working here's the updated process. So they might say this is not approved this is approved and then they might give you some feedback like update process. So, it's a very simple way that you can actually manage this workflow. Again, instead of waiting to deliver absolutely everything at once in case whatever you're doing up here is critical for the rest of the parts. You get that feedback really early. The client gets to engage with what you're building. They get to actually also come in and give you some feedback and make sure that that you're building out what they actually want you to build out as well. So, very simple process. This is

24:59also really good for generating your proposal. You have all the days, you have all the deliverables and the full scope of work. So, yeah, it's very good for clarity when you're working with clients. And at the final stage I want to speak about is handover. So typically with handover, the way that I see this is I imagine that the work that I do is going to be final. Like I'm never going

25:16to be working with the client again. Typically you do keep working with the client. If you follow all these steps, they're going to want to keep you on board. But really the best way to look at how you're building out your workflows is imagine that I never touch this again. Can the next person that comes onto here, be that my client, be that another technical person that they hire, can they like can they come into the workflow and actually just take over if anything goes wrong? can they come into here and just see what's going wrong and then try and fix things. So, the way that I do that is by going into

25:42our workflow and actually using a bunch of different notes and then descriptions on those notes. So, I'm going to come back to you in just a second, but you can see the current workflow is like this. We've got a bunch of different nodes over here. Don't mind all these red exclamations. We just haven't plugged it in. But you see all these are all the different nodes that we have on a canvas. If you're looking at a very high level and I just ask you, hey, remember what we spoke about 2 minutes ago? What's the purpose of this node or this node or this node? You might you

26:06might have actually forgotten and you've actually have to think for a couple minutes about what's happening in this workflow again. But I'm going to make some adjust adjustments to this and come back in just a second. And now we have something like this. So all I've done is I've gone into the workflow and I've just neatened everything up and I've just used notes to identify different parts in this workflow. So if we go from start to finish, for example, over here I've just defined what this workflow does. You can get as detailed as you want with this. And then I've come and I've defined for testing purposes, we're

26:35using this node for production when we go live, we're using this node. And then remember the confusion we had with all the Google Sheets nodes at the start of this right before I actually did this little adjustment over here. The first Google sheet node actually logs the email. So it logs the contents of the email. It just notes down the subject and the email body as part of our logging tool. And then the next Google sheet node actually checks what customer type it is. So over here it's very easy to see, okay, we're checking the customer type. We have an if node. If it's a customer, it comes up here. If

27:04it's a supplier, it comes down here. And now we have a way to actually break up our workflow and say, okay, we're delivering the customer workflow on Monday. So, we've come into here. And then the supplier workflow is still pending. Then we have that space to actually build it out over here. So, that's all I've really done. Generate response with the agent node. Log the response into our spreadsheet in Google Sheets. If there's an error, this is the

27:26workflow. This is the path that we take. So, I've just gone through and I've just done this. The reason that I do this is because when you actually go into your executions tab and then you trace like the green arrow as it goes into here. So like it'll be green all the way green all the way and then maybe comes into here and it's red and it fails. It's very easy for you to like very visual to

27:45for you to see what the actual error is. Then you just zoom in and you see oh it's the agent error because it's they failed with the API call or something like that. So this is really this is actually best practice when you're coding. If you're just using coding tools like JavaScript or Python and you're doing customcoded scripts or you're building out like apps and websites and whatever typically you leave some kind of like trace in the code that you're writing. So if someone else comes into your code, they can

28:09actually see what does this stage do? What does this thing do? What's the purpose of this part over here? So it's just like leaving breadcrumbs in your workflow. This is how I actually hand over all of my workflows. I will typically have some like test bat section over here. My client can come in very easy for them to see what the

28:26workflow does at each different stage. They can drop some notes for me as well and then I can come into here and look at the feedback of whatever they're saying and then kind of keep progressing with the build. All right guys, and this brings us to the end of the video. So we just went through five of these steps. So the first step is about planning, asking the client the correct questions

28:41to get the correct information for us. We spoke about logging, how to build a basic log for our workflow, how to handle failures gracefully. We also spoke about in the planning stage we asked for examples from our client so that we can actually test them in the workflow. We spoke about delivering the workflow in stages to get the client feedback, make sure that we're calibrated and then we spoke about the use of notes in our workflow to ensure a smooth handover. So just give a lot of clarity as to what's happening at which stage um and just make it easy for us to go back later on to the workflow or

29:12someone else that's new to come into the workflow and take over. If you guys enjoyed this video, I'd appreciate if you could like and subscribe to my channel. I also have a school community which I recently introduced a free tier. Feel free to come down and continue the conversation about project work in this

29:25community with other like-minded people. All right, looking forward to seeing you there. See you later.