The COMPLETE Guide to Construction Project Management

Seven out of every 10 construction projects run over budget and miss their deadlines. And it's not because people are lazy or the weather's bad. It's because people don't have the right systems and skills.

So, in this complete guide to construction project management, I'm going to teach you the systems and skills you need to effectively run any sort of construction project profitably. From estimating and scheduling to quality control and risk, I'm going to talk through all the systems and steps to effectively manage any construction project so you generate a profit, finish on time, and most importantly, nobody gets hurt.

The course is broken down into eight focused modules. Each module focuses on a specific domain of construction project management. Construction management isn't one giant topic. It's a set of repeatable practical skills.

In the first module, I'll explain the different types of skills which matter most and skills you need to successfully manage and run a construction project.

Module two is on how to manage a construction project. This is your end to end road map. Here we go through the full life cycle of a construction project from tendering to planning to delivery to close out. You'll see how each of these core skills fit into the bigger picture and what happens at each stage of a construction project.

Module three is on estimating. Profit on construction projects is set long before anybody starts work. If you can't price projects accurately, you lose money even before you start. This module covers how to build realistic estimates that cover direct and indirect cost, set fair margins, and protect you from under quoting.

Module four is on scheduling. Time is money in construction. A good schedule doesn't just tell you when work happens. It controls cost. It manages contracts. And it ensures you finish on time and keep your client happy. This module teaches you how to develop, implement, monitor, and control the schedule to ensure your project finishes on time and avoid liquidated damages.

Module number five is contract management. Contracts are the backbone of any construction projects. We need to sign one with our client and then we need to sign them with our supply chain. If you don't set them up and manage them properly, you'll lose money very fast. This module is going to give you a practical understanding of how to read, negotiate, and administer contracts so you get paid for the work you've done and avoid disputes with your client and subcontractors.

Module number six is risk management. Unlike factories, construction projects happen in unpredictable environments. We can't control the weather, the site conditions, who we're working with, or who we're working for. A variety of factors contribute to the uncertainty that is characteristic of any construction project. And risk management teaches you how to plan, prepare, and manage this uncertainty. We'll teach you how to plan for, prepare, and mitigate risks before they become problems.

Module number seven is quality and completions. Rework and defects kill your profit margins and delay handover. In this module, we'll show you how to build it right the first time to ensure everything's done correctly, on time, and there's no delays to handing over the finished project.

The final module of the course is going to be on project controls. Plans mean nothing if they don't match reality. We need to set up a feedback system that links the way we plan the work with the way we deliver the work. And that's where project controls fits in. Learn all about the essential cost tracking, schedule management, and project controls functions to ensure that you deliver the project profitably and on time.

Each module is intentionally self-contained, so you can watch them all together or you can watch them module by module. On top of that, I'm going to put a link in the description to a bunch of free resources, templates, and tools that you can use to enhance your construction project management.

Let's start off with module one, the fundamental construction management skills. Construction management isn't magic. It's simply a set of practical, repeatable skills. When I first started out, I used to think experienced supervisors and project managers just knew everything. But over time, I quickly realized that those 10, 15, 20 years of experience simply boiled down to a set of skills. A set of skills that if you deliberately try to learn and master them won't take you nearly as long.

Construction management isn't magic. It's not luck. It's a repeatable system with a specific set of tools and processes that we need to follow. You master the skills, you learn how to manage a project successfully.

There are three core categories of skills you'll need to master throughout your career. There's technical skills, so trade or discipline specific knowledge. You can't manage a mechanical or HVAC project if you have no idea about mechanical or HVAC. Similarly, you can't manage a civil construction project without some understanding of civil engineering and civil construction methodologies. You need soft skills. You need to be able to work with, communicate with people. And then the focus of this course are the construction management skills.

The six practical core construction management skills you need to master. So starting with construction management skills, these are our ability to plan, organize and oversee construction projects from start to finish. The focus is on the planning, the organizing and the coordination. The purpose of these skills is to complete the project scope. So do what we set out to originally achieve without harm. So without anybody getting hurt, without any damage to the environment, disruption to the community on time. So we finish all these tasks by our planned finish date under budget without spending too much money, and to the required quality standards. What we've said we're going to build, we build in accordance with the design and the specifications.

Construction management is all about the ability to apply the tools and processes to achieve the project objectives. These construction management skills are broken down into a set of sub-skills which are the sub-skills that we're going to focus on in the modules of this course.

So the first one we've got is estimating, which is developing the cost baseline. Working out how much something's going to cost to build before we build it and before we importantly commit to signing a contract to say we're going to build it.

Scheduling. It's about planning when the work will going to be is going to happen and then coordinating and implementing the schedule so that we complete the tasks in the right sequence to both save money and finish on time.

Contract management, which is all about understanding the terms of contracts, scope of works, managing claims and variations and payment fairly. At the end of the day, to achieve any sort of project, we're going to have to work with other companies. We're going to have a client who's paying us to do the job. We're going to have subcontractors who in turn we pay to complete the project.

Risk management. So any construction project is characterized by uncertainty. There's a whole lot of variables that we can't control. We need to be able to identify what could go wrong and put in place controls to minimize surprises and losses.

Quality and completions. So setting standards, inspecting the work, fixing and closing out defects, understanding what our client needs us to fulfill. Doing all this so that we can finish and hand over the project on time.

And project controls is about tracking our actual cost, our actual progress, comparing it to the plan, and putting in place a feedback loop. So, we're always comparing what we plan to do with what we actually do. We're fixing and we're taking corrective actions when there's any deviations from the plan.

Then finally, design management, which is managing and controlling the technical solution to the project. So when we develop a design, we're developing a design in accordance with the client requirements and then we're managing changes to this design in a controlled fashion during execution.

Now, it's important to understand that these are skills. These aren't phases of a project. These are skills that get applied across each phase of the project. For example, if we think of a skill like design management, where we typically would think of that as only occurring during the initial project design, design management occurs in all of the phases of the construction project life cycle. So in tendering or work winning, design management is used to develop a concept design sufficiently and to understand the client requirements. If we're doing a design and construction project during the design and pre-construction phase, that's when we develop the design from detail to IFC. During construction, where typically we wouldn't think about design management taking on a big role, we manage design changes through RFIs. In commissioning and completions, we close out and develop the as-built drawing set.

Another skill, for example, like estimating or financial management, during work winning, we need to develop an estimate for the tender. During design and pre-construction, we then take this estimate and transfer it into a budget and set up our cost tracking systems. During construction, we track and manage our costs, manage variations, and then during completions, we close out, do all our final payment claims, manage our cash flow, and then capture any financial or cost lessons learned. So, you can see each of these skills plays out across the entire life cycle of a construction project. They're not just used in one single stage.

We're going to go through this example of a bridge construction project to talk about how all these different skills are used. So when we're talking about construction management skills, we're talking about addressing issues like we're over budget. What can we do about it? We could look at options to change the design. So this would be a design management process where we look at raising an RFI. We could look at it from a procurement lens or subcontractor management where we say, can we find cheaper subcontractors and suppliers to save money? Can we look at our schedule and find efficiencies to finish the project faster and reduce our indirect costs? Can we optimize the sequence of activities so the actual activities are completed cheaper? Or is there some other contractual reason that we're over budget? Has the client added additional scope that we need to claim a variation? So you can see we've got an issue. The bridge construction is over budget. And then there's all these different construction management skills we're using to try and solve the problem.

Okay. Next up, we've got technical skills. So technical skills is all about understanding what we're building and how to build it. The reality is, and there's a bit of a misconception around it, you can't just be super good at construction management and understand all the processes and then manage a project successfully. You do need to have some technical understanding of what you're building. This is going to allow you to understand drawings and specifications, solve constructibility issues, know material requirements, what materials you're ordering, and basically identify and implement smart building and construction methods and value engineering opportunities.

Technical skills are the domain to which we apply construction management. So this could be a mechanical engineering project, a commercial construction project which would require you to have an understanding of building services, basic civil work. Maybe it's a bulk civil construction project or maybe it's a renewable energy project. So this is the domain we're applying our construction project management skills to it. I really break these technical skills down into three broad sets. Got engineering, which is understanding of the fundamental technical concepts like civil, mechanical and electrical. We've got construction, which is understanding the materials and methods to deliver a project. So civil engineering, we might understand what a structure is, why concrete's used, why there's steel reinforcement in concrete. Construction is all about what steel reinforcement do we buy? What's the methodology? Do we need false work or formwork? How do we get the temporary works designs approved? That's all about the construction methodology. And then we've also got the ability to use tools. So the ability to read engineering drawings and interpret them, the ability to use 3D models, the ability to use scheduling and estimating software. So these are our more or less our technical skills.

If I go back to our bridge construction project, what when when we're talking about technical skills, we're talking about things like to save money, we could look at an option to use pre-cast or in-situ bridge deck construction. Technical skills are going to help us understand what it is, how it works, how it would be built in practice, when the construction management side of this solution would be the RFI, the client design approval, assessing the schedule impact, assessing the cost impact.

So the next set of skills we've got are soft skills. So soft skills are arguably the most important because anything that involves construction involves a lot of different people. So soft skills are the interpersonal and behavioral abilities that influence how individuals interact and communicate and work with each other because again, construction involves a lot of people. It involves a lot of dealing with a broad different range of people and basically getting them to all work together collaboratively. So soft skills could be broken down into communication, which is the clear and concise expression of ideas; leadership, inspiring and guiding others towards shared goals; problem-solving, identifying issues and implementing effective solutions; time management, organizing and prioritizing tasks to meet deadlines; emotional intelligence, understanding and managing emotions in oneself and others; teamwork, collaborating effectively with diverse groups; adaptability, flexibility in responding to changing circumstances. A big one in construction. And finally, conflict resolution, navigating and resolving disagreements constructively.

If we talk about how soft skills are going to play into our bridge construction project, we had the original construction management problem that building the bridge would be over budget. We had our technical solution which was to use a pre-cast deck as opposed to an in-situ deck, which we identified would save us money. Where does soft skills come in? Well, soft skills it's the ability to convince a client, the project team that the pre-cast construction method is the preferred method. The human element of construction.

I simply want to leave you with this idea that construction management doesn't take 20 years to master. It's simply a set of skills. A set of skills that with dedicated effort you can learn. Physics, AI, and electrical engineering are complex. It's not easy, but it's also not complex. Managing construction projects is simple. Physics, AI, and electrical engineering are complex. At the end of the day, construction management doesn't get much more complicated than reading drawings, communicating effectively, and some very basic math. Importantly though, it doesn't mean that construction management is easy. It just means it's not complicated. Think of it like assembling IKEA furniture. If you rush, skip steps, and cut corners, it's an absolute nightmare. If you follow a structured, systematic approach, don't cut any corners. Yes, it might be difficult, but you control it. A project at the end of the day is just a big set of steps.

So, in this video, I'm going to give you a step-by-step framework to manage any construction project. Here's a step-by-step framework to manage a construction project from tender to completion.

So, there are two core phases to any construction project. Phase one is to secure a contract you can make money on. Phase two is then to deliver the project profitably. At the end of the day, that's all it is. You have to find and win work at the right price. Then you have to deliver the project for less than this price.

So phase one of this process is securing a contract you can make money on. It's much harder than it sounds. Why is this hard? Because construction companies, the core challenge isn't winning projects. It's winning projects at the right price. Why is this? Because there's tons of competition in the construction space. There's lots of companies chasing the same work. It's a largely commoditized industry, meaning the thing clients care about the most is the price. There's a ton of risk and complexity in projects, meaning you often end up in a situation where the client chooses the cheapest price. And the cheapest price is the contractor who's underestimated the risk and complexity of the project. Which leaves us to complete phase one successfully and secure a contract we can make money on, we need to convince a client to choose us and pay us a reasonable fee to do the work. It's actually a very challenging thing to do and the core challenge of any construction business.

So step one in this process is we need to review and understand scope. The rule I like to use is if you understand the scope, you've built the job in your head. You understand what you're building and the steps it takes to build it. It's why in the previous section when I was talking about the skills it takes to be an effective construction manager, you need to have technical skills. You need to have a solid understanding of what you're building. What happens if you don't understand what you're building? You miss scope. You end up with budget blowouts later on. So what we're going to do is we're going to review the scope of works, the drawings, specifications, and schedule. With this metric of being able to build the job in our head and also we want to try and identify contradictions. We want to ideally generate a lot of RFIs and questions to our client and clarifications. And the output of this stage is we know exactly what we're pricing.

So once we've got our tender package, we've reviewed and understood scope. The next step in this process is we need to prepare our response. Preparing our response is really answering the questions: What are we doing? How much is it going to cost? And how long is it going to take? We need to define our price, the cost of doing the work, our program, the duration we need to do it, and the terms and conditions that surround our offer. Now, when I use the expression terms and conditions here, I'm not purely talking about contract clauses and terms. I'm talking about the scope. A client may request from us that they want us to do all the concrete works, buy all the materials. We need to clearly define what we're allowing in our offer. Are we providing the permanent materials or is our client free issuing them to us? Are we doing concrete testing or is our client doing that for us? That's what I mean when I say terms and conditions.

To do this effectively, we're going to apply quite a few of the different construction management skills. We're going to need estimating to prepare the cost to do the work. Need scheduling to work out how long it's going to take and capture our methodology. We need contract management to define the terms and conditions and the scope we're proposing to, because again, this may not align with exactly what the client's requesting. And to some degree, we're going to need procurement or market engagement. For your offer to be comprehensive, it needs to cover all these key parts because they all are related to each other. The schedule you develop, how long you think it will long, how long you think it will take to deliver the project will affect your cost because of your preliminary ongoing cost. The contract you sign, the terms and conditions you accept, for example, whether you accept liquidated damages or consequential loss will affect the risk and margin you need on the project. So, you need a comprehensive approach to preparing a tender response. The output of this, you need to know exactly how to deliver the project, how much it's going to cost, how long it's going to take, and the terms and conditions you're proposing.

Now, once we've prepared that, we then need to submit our offer to do the work. We need to package clearly our price, how much it's going to cost us, our program, how long it's going to take, and the terms and conditions that surround our offer. Worst thing we can do is just send a price. We need to clearly articulate our inclusions and exclusions. For example, we've allowed for all the concrete works, including steel fixing and formwork supply and installation. We've excluded the supply of any permanent materials. A program is based on continuous work, a 12-month defect liability period, no liquidated damages, or whatever the offer is. The key here is you need to be extremely detailed and specific. Any ambiguity will come back to bite you. I can say that with 100% confidence. The more specific and clear you are, the better. If you just send back a price, your client will assume you're accepting all their terms and conditions, which you may be, but you may also not be. So, always package your offer in a way that in excruciating detail explains exactly what you're proposing to do.

The final step in this process is to negotiate and finalize the deal. This is all about clarifying the expectations. The client's asking for one thing, you're offering to do another. You need to close the gap. Come to terms and conditions that you're both happy with. That means agreeing on the price, the program, and the terms and conditions. There's typically going to be a lot of back and forward with this. And I always think when you're talking about step three, submitting your offer, you're always better to, because of the commoditized nature of the construction industry, you're always better to have a lower price and more exclusions. Because typically, a client will choose you on price, then you can negotiate your price back up or you can negotiate your exclusions to come to a deal. So, it's always better to have more exclusions and a lower price than it is to have a higher price that covers everything because they might not actually want everything they're asking for. And then the output of this phase is a signed contract and you're ready to begin work. You're ready to start spending money to deliver the project and that's the output of phase one.

Phase two is delivering the project profitably, or as I like to put it, doing the work and getting paid for it. The core challenges to this are sticking to the plan and managing the chaos. As I said, construction projects are complex and involve a lot of risk. You have almost certainly missed things in your estimate, your schedule. There's almost certainly going to be gaps between what your client expects and what you're offering to do. Again, that's why I always say you want your letter of offer to be in excruciating detail. What happens now is you've signed a contract, you've agreed on a price. Unfortunately, construction now becomes a zero-sum game. Every dollar a client pays you in variations is a dollar out of their budget for the project. In this situation, under a lump sum contract, it often becomes quite adversarial.

So, what can go wrong? You can spend more than you plan to do it. You'll lose money. You could get delayed in completing the work and incur liquidated damages or have to pay additional preliminary costs. You could have safety incidents where you're not managing risk properly. Somebody gets hurt. Could have scope creep where you do additional work without getting paid for it or an extension to your program. Your client may, you may get in a dispute with your client. They may be late in paying you and cause cash flow issues. Or you could just have disputes that damage your reputation. So these are all the things that can go wrong.

What are the steps we're going to follow to try and avoid anything like this happening? Step one in the process after we've signed the contract, we've got money to deliver the project. The first step, and this is a very broad step which has a lot of sub-activities to it, is to plan and mobilize. What we want to do, we want to convert tender into a working plan. The tender is just an estimate. It's just a bucket of money, a calculation of cost to the work. It's a high-level schedule. It's terms and conditions. What we need to develop is we need to start setting up our project. We need to develop a budget. We need to be able to track our cost. We need a detailed schedule that captures our methodology and exactly how we want to do it. Wanting to set up all our processes, our process to manage safety, quality and reporting. We need to do all our procurement. So we need to find our subcontractors and suppliers, the people who are actually doing the work. We need to order our materials. And then we need to finalize the design and any shop drawings. So drawings from vendors, any detailed design we have to do.

Now again, step one, plan and mobilize. It's a very broad step, but the output is everything being 100% ready to go. The way I like to phrase this is with pull planning. So you think about the first task in the schedule, breaking ground, earthworks, whatever it is. What is everything that needs to be in place for that activity to start? For example, we've got concrete foundations we're starting with. We need the earthworks complete. We need the survey set out. We need the design drawings. We need to order all the materials. We need the subcontractor and the labor on site. We need the site facilities. Whatever it is, always work. I like the framework of pull planning where you're working back from what's coming up next. And what is everything that needs to be in place for that to be ready.

Step two is then we've set up our project, we've developed our detailed plans, we've got everything ready to go. We then need to execute and implement the plan. This is the daily management of the site, sequencing of the works, progress meetings, short-range programming, dealing with issues as they come up, communicating with our subcontractors, our suppliers, the client, managing safety, doing toolbox talks, safe work method statements, site inspections, and then doing our regular QA checks like inspections and test plans, other inspections, client sign-offs, these sorts of things. So this is executing the plan, putting everything in place.

Step three is then to monitor and control the work. So we've planned, we've implemented the plan. Step three, monitoring and controlling is when we put in place our feedback loop. So we want to connect our plan with what's actually happening. We do this by tracking our cost, our schedule, how long activities are taking, measuring all the quantities of work being completed, subcontractor performance, qualities, inspection and test plans, and all we're doing is comparing this to the original plan. So, for example, for our cost, how much have we spent versus how much did we plan to spend? We want to maintain our registers, so any design issues that come up. We have an RFI register. We record all our defects. We record any delays and QA records. Registers are a critical part of construction management. And effectively, we're always asking the question, are we sticking to the plan? What's changing? And identifying and fixing problems early.

While all this is happening, we're planning, we're implementing the plan, we're checking, we're staying on track. We also need to manage the contract. That's why we've got step four, which is getting paid. Doing the work is different to getting paid for the work. We need to stay on top of our contract with both the client and our subcontractors and vendors. So, you need to deal with payment claims and payment terms and dates. Managing progress claims, both submitting them to our client and approving them from our vendors. We need to deal with variations, prepare them, submit them, negotiate them, get them approved. Any delays or client delays, we need to issue notices and EOT claims. We need to maintain really, really good records of instructions, meeting minutes, approvals they've given us. The goal here is not to do extra work without getting paid, to manage our subcontractors properly to ensure they're doing the work that they said they were doing. Also, one of the key elements of a contract that managing contract effectively is also managing our cash flow. We want to basically make sure we're getting paid before we're paying our vendors and suppliers to ensure that we're not going to run into massive cash flow issues.

Then while all this is happening, very related to contracts as well is we need to manage change. Change is just a reality of construction. Whether it's from not planning or preparing for something properly or some unforeseen circumstance happening, there will be change. Change can be identified early through monitoring and controlling. Then we need to both manage it practically and commercially. So commercially, if it's a variation, we'll need to provide notice to the client. We'll need to price it fairly, claim it formally and wait for formal approval. And then practically, we'll need to put the change into action, update our schedules, our budgets, our plans, and coordinate the change.

Throughout this entire process, we also want to be managing uncertainty. Uncertainty, as I've said, is inherent to construction. It's unavoidable. We need to be proactive. We need to have a risk register. Identify the sources of uncertainty that matter to the project. Rank them, prioritize them, focus on the important ones, identify the core uncertainties, and plan responses to them, and then mitigate them. The goal is, yes, things are going to change, unpredictable things are going to happen, but we want no nasty surprises. We want to have planned the worst-case scenarios. We want to have thought of everything that could go wrong. We want to consistently be asking ourselves what could go wrong and have plans in place to deal with it.

Then step seven is to complete. We want to hand over and close out the project. We want to complete all our inspection and testing. Rectify our defects. Organize our handover inspections with the clients. Do our walkthroughs with them. Identify punch lists. Close out the punch list. Prepare all the handover documentation we need to, such as O&M manuals, as-built documentation. Maybe we need to provide them with spare parts for any special products we've ordered and close out all our final accounts and claims. We want to fulfill all our obligations and provide evidence of these obligations.

Those are the steps to deliver a construction project across two phases. Phase one was to secure a profitable project by reviewing and understanding the tender documentation, preparing a response, submitting an offer, and then negotiating the offer. Phase two is then to deliver the project profitably by planning and mobilizing, executing in accordance with the plan, monitoring, controlling, managing uncertainty and change, getting paid for the work we're doing, then completing and closing out the project successfully. Again, this is a very brief overview. Comes back to this idea that construction management is simple but not easy. These steps aren't rocket science. They're not complicated. Relatively straightforward, but following them requires diligence, determination, and staying on top of everything.

Estimating is the make or break skill of any construction business. It will determine whether you win work and keep your business alive. And if you do win work, whether you make money on those projects. Whether you like it or not, and regardless of what anybody says, the construction industry is largely commoditized. Nine times out of 10, clients go for the lowest price. As a contractor, we need to be able to bid competitively, but also to manage our risk so we make sure we make money on our projects. That's why any contracting business needs to be able to estimate both accurately and strategically. So whether you're an employee or a business owner, if you work in the construction industry, you need to be able to estimate.

So, in this video, we're going to teach you everything you need to know about construction estimating. We're going to teach you what is estimating, when estimating matters, and why estimating is really a game more than a process. When and how to estimate, the components of a construction estimate, the two main estimating methodologies, how to prepare top-down budget estimates, and how to prepare detailed bottom-up estimates, then how to properly calculate and apply risk, profit, and overheads. And finally, how to review and submit your estimates to your clients to eliminate risk. Throughout this, we'll do a couple of examples and we'll be using our specialist estimating spreadsheet that I'll attach a link to in the description below.

Okay. To start with, what is estimating? So, estimating, put simply, is the process of forecasting the cost required to complete a construction project. It's about quantifying the resources we need: materials, labor, equipment, subcontractors, working out how much we need, and then assigning cost to these. So we get a total project cost. A simpler way to think about it was we take a set of drawings and specifications and we turn these into a dollar value it would take to construct them. It's the goal is to accurately calculate the costs to complete a project.

So, there are three broad categories when we need to use estimates. We use them during the feasibility stage of a project. So this would be if we're working for a project developer and we need to work out whether it's feasible to build a project. So, we need to determine how much the project will cost before we make a financial investment into it. Say you want to build a new apartment complex. You need to work out the total cost of building the apartment complex. Then work out how much you could sell the apartments for. If you can sell the apartments for more than what you can build it for, it would be feasible. But the key bit of information here to know is how much it costs to build the building. We also use it as contractors for bidding in quantity. So this is when we prepare competitive tender submissions for our clients. And finally, we use it in cost control. So this is when we're managing the project costs during delivery and we need to forecast out our cost to complete so we can manage the total expenditure.

So who needs estimates and estimators? Well, first one would be project developers when they're preparing feasibility studies, working out whether it's worth building a project. Head contractors or general contractors need them as part of their quoting process, and same subcontractors need them. Finally, the other school or group of companies that need estimators tend to be banks. So banks use them a lot to audit the viability of projects if they're lending to developers and these sorts of things.

So what about the different types of estimates? So basically, we can group estimates based on how accurate they are. We've got rough order of magnitude estimates, which would be like plus or minus 30% costs based on minimal design and concept. Got budget estimates. So these would be on schematic or early design drawings, which would give you a plus or minus 20% to the actual price. Got detailed estimates. So these are based on full construction drawings, which will give you plus or minus 10%. And then finally, we've got definitive or tender estimates. This is when we're actually quoting to complete a project. We're putting money on the line. We need to know exactly how much something will cost.

So, we've established what estimating is, when it's used, and who needs estimates. Now, let's talk about why estimating matters specifically. Why is estimating a skill that can make or break a business? So, I want to start by talking about some unfortunate realities of the construction industry. Now, whether you say these are unfortunate or not depends on your perspective, but the reality is these factors make it harder for contractors to make money. The first one is the construction industry is a relatively commoditized industry. That means clients choose contractors based on price rather than other characteristics. You look at a non-commoditized industry, maybe something like a clothing brand, like you would choose a shirt based on the fact that you like a brand. You're not looking exclusively at the cost. Construction industry though is a highly commoditized industry. Clients will choose a contractor based on a price they submit. What this does is it drives down profit margins for contractors because they need to sharpen their pencil, lower their cost to give themselves the best chance of winning the work.

Second factor is the amount of risk there is in projects. So over 30% of business insolvencies occur in the construction industry. That's going to be a factor of the fact that it's commoditized as well, but also there's just a huge amount of risk in projects. They're technically complicated. There's a lot of uncertainty. There's a lot of unknowns. You don't know how much it's going to rain for the duration of your project. It might rain a lot, in which case you have a lot of downtime. You spend a lot on delays from inclement weather, which eats into your profit margins. There's huge amount of uncertainty that impacts our ability to deliver our projects for less than what we forecast them to cost.

Next factor is that the construction industry is highly contractual. There's a lot of contracts with huge risk transfers from owners to contractors to subcontractors, and there's strict terms and conditions that surround us. There's penalties if people are late. All these factors impact the ability of a contractor to deliver a project profitably. And finally, which also feeds into how contractual things are, is that scope tends to be complex and technical. It's hard to understand as low factors. Every project is different and unique. So, the key takeaway for a contracting business would be that the lowest bidder typically wins the project. One bad project can send your business broke because of how much risk there is in these contracts. And finally, this is an important part to draw attention to now. I want to talk about it consistently as we go through the estimating course, but the offer and your estimate isn't just your price. It's also the terms and conditions that surround the price. What this means is that if you say it's going to cost $100,000 for you to deliver this project, an important part of that $100,000 figure is what are your inclusions and exclusions? Now, that is something that people often don't pay attention to, particularly the very detailed estimators who just love crunching numbers. So, if you can understand the commercial framework that surrounds your estimate, then you're going to drastically improve your performance as an estimator. If you understand that estimating is as much about the business side of construction as it is about the raw number crunching, you'll do much better.

So this leads into the role of the estimator in a contracting business and why they fundamentally matter. How they help drive profits for a business. Role of an estimator is to secure work at a price we can deliver a project. Now this is an uphill battle because of all these factors I've spoken about with the commoditized industry, the amount of risk and contracts. But the core goal of an estimator is to secure work at a price that the business can reliably deliver the project. It's much more than just plugging numbers into a spreadsheet.

So I want to draw attention to another point that estimating is an art, not a science. Two estimators can price the same job with the same drawings and come up with completely different prices and both be 100% correct. That's because estimating isn't just the science of doing quantity takeoffs, plugging numbers, taking resources. It's a business decision. It's based on assumptions, productivity rates, programs, procurement strategies, your relationship with your client, your relationship with your subcontractors, what risks you're willing to take, all these factors. There's no correct price for any job. Only a price that makes sense for your business that maximizes your chances of securing profitable work. Estimating is fundamentally a business decision. Your estimate is a function of how much your company wants to win the project, how much risk you're willing to carry, what profit margin you're targeting, how you can spread your overheads, whether you've got 10 projects or you need to allocate all your business overheads to two or three projects, what terms and conditions you're willing to accept, and accurately pricing the project isn't the goal. It's a step in the process. So what I mean by this is accurately doing the quantity takeoffs, preparing the rates, the resources, calculating the total cost is a step in the process, but the goal is to secure the project at a price you can deliver the project. That's the end goal. The process of accurately pricing it is simply a step in that process.

Now, I know I keep going over and over the same point, but it's really important. Estimating is the basis of a contract you're going to sign with your client. So you prepare a quote associated with this quote, your terms and conditions. You negotiate these terms and conditions. Eventually, you'll sign a contract with your client that has your quoted price in it. You'll sign up to their terms and conditions or whatever the terms and conditions you negotiate, and associated with this will be the contract price which you've prepared through your estimate. So when you submit an estimate, you're not just calculating the cost. It's not just an academic exercise. You're preparing to make a contractual commitment. This means any estimate has two core components: the price you prepare and the terms and conditions. The exclusions and inclusions. What scope you're willing to price, what you're excluding. I'm going to keep stressing this as we go throughout this, but your terms and conditions are just as important as your price. This means the scope of work, the exclusions, and your qualified assumptions. And the more you understand that it's as much about the terms and conditions as it is the price, you'll drastically improve the quality of your estimates and their usefulness in how they help you achieve the overall goal of securing profitable work.

So to summarize the key points: the construction industry makes decisions on price. It's a commoditized industry. If you price too high, you're never going to win work. If you price too low, you win work, but you'll lose money on the project, which is a much worse result and sends construction businesses broke all the time. Estimating is how you find the right balance between the two to win profitable work.

Okay, so we've established the role of the estimator and the goal of the estimating process. Let's now talk about construction costs. What are all the different types of construction costs and how do you put them together to prepare a cost estimate? So before we can talk about how to prepare an estimate, you need to understand construction costs. This is the foundation to understanding estimating, the different types, and where and how we spend money on construction projects. So this diagram I love because it simplifies all the different components of construction costs. We go through each of these in more detail, but broadly we can break down all the different costs we incur to deliver a construction project into the following categories. We've got our direct costs, the costs of doing the physical construction work. It consists of labor, materials, plant, and subcontract costs. Then we've got our indirect costs. So these are the costs to supervise, manage, and facilitate the work. So we've got recurring costs, so ongoing costs we incur throughout the duration of the project, and we've got non-recurring costs, so one-off indirect costs. Sum our indirect and direct costs together, we've got our total project costs. And then on top of this, we need to provide our markup. So, we've got our margin, our corporate overhead, and our risk and opportunity.

Okay. So, direct costs are directly tied to completing the physical works on site. So, these are costs we incur to complete what's shown on the drawings and specifications: pouring concrete, excavating, installing electrical cables, procuring plant that we need for the project. These are all direct costs. They're measurable and vary based on the scope of the project. For example, if we need bigger concrete foundations, we'll incur more cost to build these. Four main types of direct costs: we've got labor, materials, plant and equipment, and subcontract costs.

The first type of direct costs are labor costs. So labor costs include wages, allowances on costs such as super or workers compensation that are paid to the people completing the physical works on site. These are always going to be a function of the labor rate we have and the labor productivity. So for example, how many square meters per day of formwork can a form worker install? How many tons of steel can a steel fixer install? These productivity rates would drive the total project cost. Labor costs are going to vary depending on the skill level or type of labor we need. So, for example, do we need an electrician or do we need an unskilled laborer, the work type they're doing, and the project location.

The next bucket of direct costs we've got are our material costs. So, these are the raw inputs to delivering the project. The concrete, the reinforcement, the electrical cables, maybe we have to buy air conditioning units if we're building a building. These are our material costs. And included in these, we need to allow for the actual supply of the materials, the freight to site and delivery, and any wastage impacting this. These prices are often going to be the most volatile and subject to escalation. So for example, if copper prices go up significantly, then the cost of buying electrical cables is going to also increase.

Then we've got our plant and equipment costs. So we've got hired or owned equipment needed for construction. So for example, cranes, excavators, concrete pumps, tooling, specialist equipment like that. Within these costs, we need to include the mobilization and demobilization costs. So for example, getting the piece of equipment to and from site, any fuel servicing, and operating costs, but they will typically be included under labor costs unless we have some sort of wet hire supply agreement. These will need to align with the productivity assumptions we're using for the labor as well. So for example, we have an excavator operator and an excavator will typically combine these rates together to get our built-up excavation rate based on the expected productivity per day. But again, I'm going to cover all this when we go through how to actually build up our direct costs. For now, we're just talking about understanding these different types of costs.

The final type of costs we've got are our subcontracted costs. These are quoted prices for packages of work such as electrical, plumbing, formwork. If we package up a section of work,

We get a lump sum price from a subcontractor to complete all the electrical work on our project. Typically, we'll get lumpsum pricing. It's also a good practice when we're going through this to understand and validate the cost build up the subcontractor has given us in case they've made some big mistake or error and how they're doing it. We could get more complex in our contractual relationships with how we engage the subcontractors. We could do certain risk sharing agreements with them or we could have or they could have certain exclusions that we'll need to account for. So subcontractor costs not as simple as just letting and forgetting. We really need to understand their cost build up and how they price the work and what they're excluding and including.

So those are our direct costs. The cost of completing the physical construction works. Let's now talk about our indirect costs. And again there's two main categories of these. We've got our recurring indirect costs. So, you're going to be driven by the duration of the project. And we've got our non-recurring one-off costs. So, our indirect costs are costs required to run the project, but they're not tied to individual work items. So, these are big costs like site supervision, site office setup and operation. temporary work. So if we need to put in a temporary access road, site utilities, so getting power, water, gas to site as required, safety compliance, permits and approvals, and they typically form a very large portion of the overall project cost for maybe around 30% would be a standard industry figure, but it will vary a lot based on the specific type of the project.

So recurring costs are ongoing costs incurred throughout the project life cycle such as staff salaries and the key point here is they're driven by the overall duration of the project which means to accurately calculate them we need a schedule. The other type are the one-off costs. So these are incurred at a single point in time during the life cycle of the project such as mobilizing to site or maybe freight costs.

To get our total project cost, we sum our direct costs and our indirect costs. Now the total project cost is what it would cost us to complete the project based on our assumptions and understanding of the scope. So that's what we would need to spend to deliver the project. Okay. So total project cost is an estimate of the total project cost and it's missing an important number of elements. The first one is contingency and risk. So these are used to covers unknowns and uncertainties certain events and conditions. We don't know how much it's going to rain. We don't know exactly what the ground conditions are like. Maybe the design is only a concept design. There's going to be further design revisions which might cause us to incur additional cost. All these factors will contribute to the amount of uncertainty in the project. More uncertainty, the more contingency we need to allow. The less uncertainty, the less contingency we need to allow. Ideally, we'd have some sort of risk register with estimated dollar values against all of these. But the other way to do it is simply have a percentage marker on the total project cost.

Now, so far we haven't actually applied any profit margin to our project. So if we submitted the price we' prepared to the client, we'd be doing the job free. We need to apply some sort of profit margin or markup to the cost to ensure that it's worth doing the project. That's our profit margin. This is going to be business decision, not a cost. It's based on the market, what we can get away with. Some projects if we're contendering them, there's no competition. We could have a much higher margin. There's lots and lots of competition and we need to have a very competitive price to win. We'd have to have a very low profit margin. Profit margin should reflect the overall risk. So any unknown unknowns, the level of competition, the desired profit and our corporate overhead. So in competitive markets, this is going to be squeezed down. So that's why it's essential to understand our true costs.

So now we understand all the different components of construction cost. We understand direct cost, indirect cost, risk and opportunity and our markup margin and corporate overheads. Now I'm going to start talking about how you actually go about calculating these costs. We're going to start talking about different estimating methods and the two main types of estimating methods you need to understand.

So there are two main estimating methods we use. There's the top down budget estimating approach and there's the bottom up first principles approach. They vary based on the level of accuracy and the level of effort. More effort you put in, you'll get a more accurate price. The less effort, the less accurate. Pretty obvious. The top down approach is a quick highle method of estimating based on cost from similar past projects or even past estimates you prepared that you're very confident in. Rather than breaking down the project into every single activity and calculating costs associated with it, we simply apply unit rents or multipliers to the overall project scope. For example, if project A cost $10 million and project B is 50% smaller, we assume that project B will cost $5 million subject to any adjustments to the scope.

Remember back to the types of estimating when we spoke about different types of estimating and the percentage range of accuracy with these. The top down approach is where we would be we would use when we've got higher variabilities in the accuracy and getting a finalized price isn't particularly important. So we use it with early feasibility studies, early stage client discussions, rough order of magnitude pricings when the design isn't finalized and when you're scoping out whether to pursue a project or not. Basically, you use it whenever there's not money on the line and you're not signing a contract to commit to a price. The top down approach is good when you want fast and easy pricing, when you're just making highle decision making. It's also a really good way to verify a bottom up estimate. So, a good way to check a bottom-up estimate is to first prepared a top- down estimate so you know roughly how much the total project should cost. When you're doing a detailed estimate, the two should align. So the limitations of a top- down estimate is they lack the detail and miss unique scope differences. They rely heavily on historical accuracy and similarity and they're not suitable for formal bids or signing contracts.

Bottom up estimating on the other hand is where instead of taking an estimate from the top down, you build the estimate from the bottom up. So this is where you build the project costs by individually breaking the project scope down into component pieces and against each piece calculating the cost of doing that scope. The process would be you create a work breakdown structure of the overall project. You price all of the individual activities. You sum the direct cost together. You estimate the indirect cost and you'll need to prepare a proper project schedule to do this. Then apply profit and overheads. You should use the bottom up approach when you're preparing detailed tender submissions. You're using detailed cost planning. You're preparing pricing to sign a contract. And basically anytime you need accuracy, traceability, and defensibility. You're putting money on the line. If you're preparing to sign a contract, you need to do a bottomup estimate. So the advantage of a bottom-up estimate is you get a high level of accuracy and control. You get transparent and traceable pricing. It allows better analysis and change management and it supports confidence in your pricing. So limitations of a bottomup estimate is it's time consuming and resource intensive to do it properly. It requires detailed design and scope clarity. You actually need detailed drawings and specifications to prepare it and it demands more skill and expertise. And add to that final point that is easier to make mistakes in a bottom-up estimate than there's in a top down estimate. It's very easy to miss scope, use the wrong rates, misquantify things. It's much more errorprone. It needs to be checked more thoroughly. The approach I like to use is always to combine the two. So for example, if you're preparing bottom up estimate, you'd start with the top down estimate, prepare a rough order of magnitude approach based on the budget estimating approach, and then you could do a detailed bottom-up price to check and validate these two prices.

Okay, so so far we've covered what estimating is, the different types of construction costs, how and why estimating is used, and the two main estimating approaches. Now, let's talk about when to estimate. When during the typical life cycle of a construction project do you need to prepare construction cost estimates? Okay, so if we look at the four main phases of a construction project life cycle, we've got feasibility, tendering, construction, and close app. ing feasibility. We use estimating to help us determine the initial feasibility of a project. Say we're working for a project developer. We then use estimating during the tendering phase to secure new work from clients to quote jobs. This is the main use of the estimating what people traditionally think of. We then use estimating a lot during the construction phase of the project. This is when we're pricing variations and change. We also use it as a forecasting and cost control tool. Then finally, we use estimating a little bit in the closeout phase to help us do retrospective analysis, look at our actual costs versus our plan costs. Basically to review the project and improve our estimating processes going forward.

So estimating during the feasibility phase. This is where we use estimating to help us make the business case for a project. Say we're working for a renewable energy project developer. We want to decide whether it's worthwhile to build a solar farm. Part of this equation is working out how much electricity will produce by the solar farm, our revenue, but also part of it is working our anticipated capital cost to build the solar farm, which we use estimating for to calculate the cost of building the project. During the feasibility phase, we typically won't do detailed bottom up estimates for the sole purpose that we don't have any design drawings or concept documentation. So in the physibility stage, we tend to use top- down estimating to prepare rough order of magnitude prices. We compare these to benchmark projects. For example, dollar per square meter rate for earthworks or buildings or we might use dollar per watt for a solar farm. We factor in highle risks such as site conditions, escalations, inclement weather. And we use this information to provide input for our business case approvals, investor board presentations, and preliminary funding estimates. The feasibility stage is characterized by rough order of magnitude estimates. So design is usually low, incomplete or conceptual at best. This results in low accuracy estimates and it's ultimately used as a basis for key decision- making. We don't have to be plus or minus 1%. We're not signing a contract to deliver the project for this cost. but more or less using estimating as a tool to make informed decisions that feasibility and viability of building a project.

Okay. Next, the tendering and procurement phase of a project. The developer has decided to proceed with building the project. They now need a contractor to deliver the project and then that contractor will eventually need subcontractors. This is typically when we think of estimating being used when we think of estimating. So we use it to submit competitive accurate offers that win projects at a price we can deliver them for. So estimating in this phase is used by the contractor or the general contractor quoting to the developer or the subcontractors quoting to the general contractor. Instead of using top- down order of magnitude estimating because we're getting ready to sign a fixed lump sum contract, we use bottom up estimating based on a detailed scope of works and design drawings. We'll conduct quantity takeoffs, calculate direct and indirect cost, obtain our own subcontractor and supplier pricing so we have a very accurate understanding how much the project will cost to deliver. We review contract terms, identify risk, apply contingencies, set our profit margins, and as the contractor, we will produce a submission with clarifications, assumptions, value engineering opportunities that ultimately a finalized price that we're willing to sign a contract to deliver the project for. So during the tenering procurement phase, estimating is used as a tool to sign a contract. the value we estimate the project to cost. We will eventually sign a contract to say we can deliver the project for that value. So it's essential that our estimating here is incredibly accurate. This is where contractual commitments are made around scope inclusions exclusions and ultimately price. Poor estimates here lead to loss losses for contractors, disputes and delivery issues and strategic pricing decisions need to be made. So whether we want to get more work, so we opt to go in with a lower profit margin and more risk, or whether we've got a big pipeline of work, so we're not particularly keen to win the project, unless we can do it at a very healthy profit margin. So while estimates must be grounded in real costs, ultimately here is where a lot of the strategic pricing decisions around the project are made as well.

So we sign a contract and we begin completing work. Estimating is also used in the construction phase to help us manage costs to track performance keep delivery aligned with the budget and also importantly to help us prepare and submit and get variations approved. So how is estimating used in this phase of the project? Well tender estimate what we prepare to tender our price to deliver the worked will eventually become our budget to complete project. It's used to set our package budgets, our procurement targets, our cash flow forecast. So ultimately to set up this budget, we need to understand how the estimate was put together. As conditions change during construction, what we also use estimating to reestimate our costs to complete the project. In addition to using estimating to price variation, so when the client changes a contract work, we'll need to prepare estimates and get them approved. We use estimating through subcontractor negotiations. So to understand their own price buildups to negotiate efficiencies and identify value engineering opportunities to review and approve progress claims and for forecasting our cost to complete to manage our own budgets. Okay. So, while we're not going to be doing the heavy intensive estimating like we did in the pre-construction procurement and negotiation phase, we're still going to be using estimating here a lot as a tool, but more of a tool to understand our own cost builds and to prepare and submit variations. So, we still need to have a really good firm understanding of construction estimating to manage this phase of the project properly.

Okay. Finally, during the closeout phase of the project, we use estimating to compare our actual performance, our estimated performance and refine future estimating accuracy. So, we're not necessarily using estimating to improve the performance of the current project we're on. We're going to use estimating to improve the performance of our business processes going forward. How's estimating used in this phase of the project? We're going to conduct cost reconciliation exercises. So looking at our estimated cost versus our actual cost to understand what the difference is. We want to identify the key differences and the root causes. Did we have poor productivity assumptions? Did we have scope crit? Did we actually do additional work that we didn't get paid for? Or did we miss tasks when we were preparing our estimates originally? This feedback is going to help build our historical cost database for our project, our productivity benchmarks, and our risk and pricing assumptions going forward. This whole purpose is to help us improve future tenders, understand how we can price more strategically, but also help us to improve construction going forward. So the key considerations here is a robust closeout review can improve your tendering going forward because you actually better understand how much things cost, where you're making mistakes, where you're missing things, and how to improve this. So you can be leaner and sharper with your pricing, but have a better understanding of project risk.

Okay, so now we've spoken about how estimating is used in the different phases of project delivery. Now we're going to do a deep dive into top down or budget estimate. This is where we prepare our rough order of magnitude prices using comparison data from other projects.

Okay, so what's the process for preparing an order of magnitude or a top down estimate? The first thing is we need to identify a relevant or reference project. Now, this could be multiple projects. This could be one project. Or this could even be if we don't had an exact replica, an accurate estimate we've previously prepared. That would be the worst form of budget comparison. You're much better going off actual cost data. Next, we want to calculate the relevant unit rate. So, what is the key quantity that describes the project? Building a solar farm, it'll be dollar per megawatt. For building a railroad, it'll be dollar per meter. If we're doing drainage, it will be dollar per meter. If we're doing an earth words project, it might be dollar per meter cube. We then want to scale that rate to the quantity of the new project. So we multiply the unit rate by the no known quantity for this new project. We adjust for known scope differences. If there's specific changes to the scope, we can use more of a bottomup approach to adjust the cost by these. Then we finalize our estimate and document our assumptions clearly and how we've repaired this so it's traceable and understandable if anybody wants to review it.

Okay. Okay, so I'm going to give you a quick example of estimating the cost of a solar farm based on historical data from a 25 megawatt solar farm. So step one, we're using our historical data to get a benchmark rate. So this 25 megawatt solar farm we previously delivered for $30 million. So we divide $30 million by 25 megawatt to give us a unit rate of $120 per watt. Step two is then to scale the cost to the new project. So the new project will be 20 megawatt. we apply the same unit rates. So we take a $120 per watt multiplied by 20 megawatt gives us a cost of $24 million. Okay, so on this project we need to adjust for some known scope differences. The key one being that on this project the client is going to free issue the inverters to us. So we know the inverters cost around 10 cents per watt. So we change our unit rate. We take a $120 per watt. We adjust for the known scope differences which is the client free issuing inverters. we get a new rate of $110 per watt which gives us a new total cost for the project of $22 million. Then we document our key assumptions. So based on similar project scope, scale and site conditions, we document that we've excluded the inverter supply and we've made no allowance for escalation design variation or sight specific challenges. So anyone who reviews estimate knows clearly how it was prepared and what key qualifications and assumptions associate the price. As you can see, rough order of magnitude pricing is quick and easy. Simple and straightforward. The key thing is it relies on historically accurate past project data. If you don't have good cost data on a previous project makes doing a rough order of bank price almost impossible.

Now, in this section, what we're going to move on to talking about is first principles estimating. So, taking the opposite approach, rather than just simply copying another project and adjusting it as needed, we're going to build up our estimate from the bottom up. We're going to break the project scope into pieces, price each individual activity in detail.

Okay. So, what's the process to build a bottom-up estimate? Well, first off, we need to calculate our direct cost. We determine the cost of physical deliverables. We then calculate our indirect costs, the cost of supervising and managing and facilitating works. We then apply our risk and opportunity and markup. So our profit markup and our corporate overheads. We then need to review this, check it for errors, make sure we're confident in it, draft it into a letter of offer, and submit it to our client.

Okay, so step one is calculating direct cost. The cost of completing physical construction works. This is four steps. So step one is to create a work breakdown structure where we decompose the project scope into deliverables. Step two is to form a quantity takeoff where we measure each of the key quantities. Step three is to estimate the direct costs. So we've got our activities, our quantities. Then against each of these activities, we calculate the labor plant material and subcontract costs to complete that activity. Step four is to summarize these group the costs to calculate our total direct costs.

Next step is to calculate our indirect cost. So the process of calculating the cost to supervise and manage the work. First step and this is critically important when calculating indirect costs is we need to identify what they are. So unlike direct costs where we can look at a drawing that shows we have to excavate, we have to pour concrete, we have to install electrical conduits, indirect costs are costs that we will have to identify what they are. What are the costs we need to supervise and manage the work. So step one is to identify the applicable indirect costs. We then need to determine what our recurring indirect costs are. So we need to determine how long the project will take us to complete. So we need to calculate a schedule. Then we calculate the cost per unit of time for each of these indirect costs. The recurring indirect costs we need multiply them by the project duration and then we need to calculate our non-recurring indirect cost. So these are costs we calculate in the same way using the same process as our direct costs. We then combine our direct our indirect costs and we need to add our marker. So our risk and opportunity an estimate is uncertain. It's a prediction of what we think it's going to cost. So we need to adjust for the uncertain events and conditions that can impact our price. We can either make allowances on a percentage basis or we can do a full risk and opportunity register and apply costs and probabilities to each items. Once that's done, we need to apply our margin. So this will be our profit margin, what money we want to make for the business from the project and also our corporate overheads. What non-specific project costs do we need to recover a portion of? You don't need to submit our estimate. We've prepared our cost, our markup, we've got our sell price. We need to then review this. We need to check it for errors, emissions, and accuracy. Then we need to draft up a letter of offer where we clearly detailed the scope. We've priced, our inclusions, our exclusions, our allowances, and then put in our pricing schedule and submit this to the client. So, that's the overall process we use to prepare a bottomup estimate. Now, we're going to dive deeper into each of the stages of this process, and we're going to start by talking about preparing our direct cost, the cost to do physical construction works.

So, direct cost is a cost that can be directly traced to specific construction activities such as earthworth, concrete foundations, installing electrical cables and services. the cost of physically doing the project, the cost of physically doing the work. They vary based on the size, complexity, and scope of the project. There's four core types of direct costs. We've got our labor costs, our plant and equipment costs, our material costs, and our subcontract costs.

So, the first type of these costs, and most likely depending on specific type of your business, the labor costs. The labor cost will be the wages, allowances and on costs applicable to the people doing the work. So this is going to the total labor costs will be dependent on your productivity factor. So your task productivity such as manh hours per meter squared and formwork your overall productivity factor. So what percentage of the time that somebody's at work are they working? So typically this will be something like 85% once you factor in the setting up in the morning, lunch breaks, smoker, these sorts of things. And your daily productivity per crew. So if instead of working as an individual such as someone doing formwork, you might have a daily productivity. So a crew of three people can trench 50 m per day. This will depend on crew size and composition. So whether you're using form workers, steel fixes, electricians, all these different types of labor will have different labor rates. Now most of that is pretty obvious. One key consideration I'd like to draw your attention to is that when people think of labor costs, they think of salary times time. But they miss an important component of this, which is the on cost. So on costs contribute significantly to overall labor cost. So on cost to cost like superanuation, workers compensation insurance, payroll tax, leave entitlements. So if you're employing someone, you still need to pay them sick leave, annual leave, public holidays, and any sight specific allowances. So within the EBA, they might have travel allowances, site allowances, and tooling allowances. So to calculate labor cost, we take the base hourly rate that someone's paid. Say someone's paid $50 an hour. We then apply our on costing to this. So this will be typically in the order of 25% to 40% the total cost. So we take someone who makes $50 an hour. We apply 30% on cost. The cost rate the cost of them working 1 hour is $65 per hour. We then take the productivity factor. So for example, if we're using a crew can trench 50 m per day, we then get a labor cost per meter. So, if we take 30 hours of work by $65 per hour divided by 50 m, our co our labor cost per meter of trenching is $39 per meter. We can then apply this to the total volume of trenching to get a total labor cost that activity. An important point I'm going to draw your attention to is I use the daily productivity there. If you're using an hourly productivity, you have to adjust by the productive time. what percentage of the time that somebody's at work and they're working as opposed to being on lunch breaks setting up for the task and these sorts of things. That's why in my mind it's easier to use daily productivities when you're doing this.

The next bucket of direct costs are our plant and equipment costs. So plant equipment costs include things like machinery and equipment used for the construction work. These might be cranes, excavators, concrete pumps, scaffolding, tooling, these sorts of things. We have to factor in the actual usage of a plant and equipment as well as mobilization and demobilization costs, fuel, servicing and maintenance. With our plant and equipment costs, we can either have hired plants or owned plant. We can own a piece of equipment or we can hire it from someone else. With our hired plant, much easier to calculate is we just charge the daily or hourly rate that we use. This can include the operator, so being wet, hire, and basic servicing. We need to look at the specific terms and conditions of the hire. For example, we might for a concrete pump, we might get charged $1,200 a day. With owned plant, we still need to charge the plant to the project we're working on or the business won't recover the cost of owning the plant. The costs of own plant include depreciation, so the original capital investment minus the final sale price spread over the lifetime of the asset. any financing, so interest or lease payment costs were incurring, servicing and maintenance on the plant, and fuel and consumables. So, own plant rates are a bit more complicated to calculate. Some key considerations with plant costs are utilization rates, so not factoring in idle time for plant. The easiest way to do that is simply use the same productivity and hours for your labor for your plant. So, for example, you're trenching 50 m per day. That excavator that's being used for the trenching is allocated for the full shift to the trenching activity, even if it's only used half the time. Overestimating plan costs is also a problem when we're overallocating cost to the project and missing mobilization and demobilization costs, which depending on where your project is, are often significant.

Okay. The next bucket of costs are our subcontractor costs. So these are costs we pay to external subcontractors and suppliers. This can be on a lump sum basis where we get a full quote to deliver a package of works as per the drawings or it can be on unit rate cost. For example, we get a rate per lineal meter of saw cutting. Typical subcontractors that might be used on a project could be electrical, plumbing, structural steel, roofing. Within the subcontractor's lumpsum price, they'll provide all labor, plant, materials in their fixed cost.

Okay. So, how do we handle subcontractor costs? Well, the first thing is we need to develop a detailed scope of works with clear inclusions and exclusions and then with verified quantities. It's always better, particularly when you're tendering work and you're not necessarily in a position where you're ready to sign a contract with your subcontractor. It's always better to do your own quantity takeoffs of their work so you understand everything and you ensure that they don't just give you some quick dirty price and a miskeeping. So perform your own quantity takeoffs the subcontractor's work. Give them scope of works with clear inclusions and exclusions. What are they providing? What are you providing? And get three to six quotes for the work. Don't rely on the cheapest price. Take the average price. Perform a detailed gap analysis and make sure you adjust their prices accordingly for any scope they've excluded that you're not aware of. Perform a high for big important subcontracts. perform a highle first principles check and include the middle price in your estimate but not the cheapest one.

The final cost bucket are material cost. So the cost of the raw materials, concrete, steel, reinforcement, electrical cables, plumbing materials, these sorts of things. It's going to depend on our quantities and our unit rates. We need to factor in freight and wastage. When we're doing this, the actual process to counter the material cost is incredibly similar to subcontractor cost. Unless we have some sort of unique business model where we also make our own materials. Most in 99% of cases, we'll be getting quotes from external suppliers. So, we can use the process of getting subcontractor pricing to get our material pricing.

Okay. So, where are we at? At direct cost, the cost of completing the physical construction works for each activity. We need to calculate the labor cost associated with it, the plant and equipment cost, the materials and the subract subcontract cost. We sum those together. We get the direct cost for a specific construction activity. As an example, let's do direct cost estimate of building a concrete slab. Now, all we're going to be doing is supplying, installing the concrete, the reinforcement, and formwork. We're not going to worry about excavation or any preparation work such as survey set out. The scope of the project is to construct a 100 m squared 150 mil thick concrete slab. So first thing we need to do is we need to get our key quantities by doing our quantity takeoff. So our concrete volume is 100 m squared by 150 mil thick. We need 15 m cubes of concrete. A formwork which we need around the perimeter of the slab is 40 linear meters by 0.15 m deep and we so we require 6 m square of formwork and we need the reinforcement. We're going to use a ratio method to calculate this. So we need we're going to assume there's 100 kg per me cubed of reinforcement for the 15 m cubed gives us 1,500 kg of reinforcement. Then each of these tasks we can take the quantity and the rate to calculate the cost. The concrete supply we need 15 m cubed of concrete. Our rate is $250 per me cubed which gives us $3,750 for the supply. For our reinforcement supply, we need 1,500 kg at $1.50 per kilogram gives us $2,250 for reinforcement supply. For labor, we're assuming to install the formwork, to place the reinforcement, and then to pour the concrete, we need three workers for 8 hours to do the entire slab. Our cost rate, so our uncosted rate of labor is $60 per hour, which is $1,40 for labor. And we're going to need a concrete pump for one day at $1,200 a day. This gives us the total cost of performing a slab of $8,940. Now, these numbers are just made up. They don't mean anything. If I look at those labor numbers, that looks very lean to construct that slab. You get the general point. You go through each of the items. We take the quantity, the rate to get total. We sum those together. We get our total direct cost for constructing the concrete slab.

Okay. So, let's go back to our estimate components and let's look at where we're up to. So, we've done our direct costs. We've worked out for the construction activities we're needing to deliver the project. We worked out our labor, material, plant, the subcontract costs. We've done this for every activity in our work breakdown structure. We sum all these together. We get our total project direct cost. Now, we need to move on to calculating our indirect costs. Let's move on to doing our indirect cost.

So indirect costs are the cost of supervising, managing and facilitating the work. Now remember our direct cost we can calculate by looking at the drawings, going through all the different drawings and working out everything that needs to be done to complete the project. Indirect cost is a bit more challenging because we need to come up with what are the costs as the contractor we're going to incur to manage the work. It's not going to be shown on any drawings. We're not going to see the crib facilities, the toilets, whether we need a security guard at night. That's why the challenge with indirect cost is making sure we've covered everything. So indirect costs are expenses necessary to run the project, but cannot be directly linked to a specific construction activity or work packages. They support the overall project delivery, covering site operations and compliance, but they're not going to be shown on any drawing. also known or referred to as preliminary prelims or site overhead and running costs.

So, why are indirect costs so important? First off, they are often underestimated eating into profit margins when you're delivering the work. They're also driven by the project duration, which is an incredibly hard figure to calculate. So, there's a lot of risk in estimating the duration of the project, which will ultimately drive the total indirect costs. Finally, they're hard to quantify. Unlike direct costs where we can look at a drawing to identify them, indirect costs are much more subjective and project dependent.

So now we've got to go through a key categories of indirect costs. First one are our site supervision and management costs. It is costs like project managers, site engineers, foremen or even some salary or wages workers that are working to help supervise and manage the work such as logistics people. We've also got support staff such as document controllers and safety officers. And these costs are going to be like with our labor costs. These are going to be a combination of their salaries and any on costing that applies. Salaries are going to be duration based. They're going to be recurring costs that are driven by the overall project duration and length. Next category are our site establishment and facilities. This would be the setup and removal of our site compound, purchasing or renting a site office and the fit out and setup, any amenities we need such as toilets, lunchrooms, first aid stations or site fencing, signage and security systems or security guard at night to prevent people breaking in. Then we've got any temporary works we need to perform to facilitate the works. These would be things like access roads, scaffolding, shoring, formwork not part of the permanent structure. If we had to do like a working platform for a crane, hoardings, traffic management setups, these are all necessary to carry out the work safely and efficiently, but they're not going to be shown in any drawings. So, these are temporary works that we have to install and then reinstate at the end of the project. Now in a lot of situations you would cover these within the direct cost of the task. For example, if you're doing a concrete structure and you need false work on scaffolding for that, I would recommend including that as it's associated with one specific task in the direct cost. However, if you're erecting a scaffold tower to get access to a roof where three or four different trades need to work, then that would be covered as a separate indirect cost because it's related to multiple different costs. the line is a little bit gray and blurry and particularly around temporary works is where it's incredibly easy to miss things. So just make sure you've thought through the actual construction methodology and what temporary works need to be in place to facilitate the works. And we've also got utilities and consumables. So these are things that be like power, water, fuel for generators, consumables like PPE, office supplies, cleaning materials, waste disposal, environmental compliance. So waste disposal can be quite a significant cost on projects. The logistics of how you manage the bins, how much waste you produce, whether subcontractors are taking away their own waste. All these things need to be considered and covered in your indirect costs. Next, we've got costs by permits, insuranceances, and compliance. So local council permits, road closures, environmental fees, project specific insuranceances like contract works insurance, public liability, bank guarantees, retention, financing costs, and safety compliance. So training cost, audits, documentation, all sorts of costs that we need to comply with laws, regulations, and contract requirements. Now the next cost which might be huge if you're working in a remote area of Australia or might not really be that significant if you're working in the middle of the city and mobilization and demobilization cost. So this is transportation of equipment and personnel to and from site including the mobilization of plant cranes and heavy machinery. Setup costs for subcontractors. All these sorts of things will need to be covered in your preliminary costs.

Okay. So broadly speaking, those are all the buckets of indirect costs you incur to deliver the project. They will be specific to the project you're working on, where you're working, the country you're working in, all these sorts of things. So how do you calculate these costs? The first step is you need to understand how long your project will take. Most of these costs will be driven by time, which means the longer the project is, the more of these costs will acrue. The shorter the cheaper the project will drive the staffing, the site facility needs, the utility costs, all of these timebased costs. The next thing you need to do is you need to quantify and identify all the applicable indirect costs. So how many people do you need for how long? What sort of people do you need project managers? Do you need site engineers? What facilities do you need? Do you need an office building? Is the client for issue that? All these sorts of things you need to work through and identify every single applicable indirect cost. Now, as I said, because these aren't going to be shown on the drawings. This is where you need experienced people who've delivered the exact type of project you're working on to help you identify the specific indirect costs you're going to incur. Then, depending on whether they're a recurring or reoccurring cost, you need to apply unit rates to salaries, higher rates, and utilities. For example, a site engineer, they cost $100,000 a year. 12 months, that might be like $8,000 a month. For an office rental, that would be $2,000 a month. And then you multiply these by the durations of the project. Then for your nonrecurring indirect cost, you'll simply add these on and calculate them in the same way as you would any direct cost. So these are things like mobilization, permits, one-off compliance fees, insurance premiums based on the contract value. these sorts of things. You add these on and these are your non-recurring indirect costs. Okay? So, when you're talking about indirect costs, time is such an important driver of these costs. If you have a 40week program as opposed to a 30week program, you've increased your indirect costs by 33%. So, it's really important to understand the duration of the project. Now, I'm going to dive more into the realms of contract management, but it's why it's so important to have a program that you've based your price on. And that program forms part of the contract with the client because for whatever reason the client delays access the site, delays free issuing you materials, holds you up in any way, you need some mechanism to cover the additional indirect costs you'll incur by them extending the duration of the project. The other important thing to note is that even if you remove direct costs, whatever the client descopes you, reduces the amount of work you need to do, often your indirect costs will still be incurred. So, it's really important to understand what these are and to also show them to your client in a way that makes negotiations much more easier and they're not necessarily built into the direct cost items into the pricing schedule. But also understand the contract specifics and because some indirect costs may be reimburseable or they may be covered by your client if they're free issuing you site facilities, office rooms, toilets, first aid, these sorts of things.

Okay, going back to our breakdown of the total project costs, where are we up to? Well, we've done our direct costs, we've done our indirect costs, we've calculated our total project costs, we know how much money we will need to spend to deliver the project. Now I need to move on to working out our markups, our risk and opportunity, our profit margin, our corporate overheads.

Okay, so the first of these we're going to talk about is risk and opportunity. Our estimate is an estimate. It's based on uncertainty. It's based on uncertain events and conditions. We don't know exactly how much it's going to rain throughout the execution of the project. If it rains a lot, we have a lot of standown. We have a lot of people sitting in cryptions that we're still paying while they're delivering the project. We have to do a lot of rework to our earthworks because it's ran so much. Then we're going to incur a lot of additional costs. On the other hand, if it doesn't rate at all, we're going to have saved a lot of money if we've made allowances. Our estimate is based on uncertainty. So, we need to understand how to properly manage risk and opportunity.

Okay. So, put simply, what is risk? So risk is the chance your project will cost more or take longer than you estimated due to unknown or uncertainties. An opportunity is the opposite. It's the chance of reducing your cost, increasing your margins, getting additional revenue that all add value to your project again based on unknown and uncertainty. Process of estimating properly is the process of controlling uncertainty. Every estimate contains assumptions. things we believe to be true but can't fully guarantee. Risk and opportunity management is how we stay realistic and competitive in the face of uncertainty.

So now I'm just quickly going to go through the major sources of risk in any typical construction project depending on the specifics of your project. Some of these might be very applicable, some of them might not be applicable at all or there might be completely other categories that you need to think about and consider. The first one which happens on most projects is unclear or incomplete scope. There might be inadequate design or design details as you're pricing the job on a 30% or even a 15% design. There might be poor client expectations being defined poorly in the scope of works or the contract. And the risk is that you underpric the job because you don't fully understand what's involved in delivering it.

Okay. The second type of estimating risk would be material and supplier price increases. So typically around 70% of a project's total cost will be outsourced to subcontractors and suppliers. Of this there's always a chance that when you're getting quotes when preparing your estimate from suppliers and subcontractors, but by the time you go to then sign a contract and deliver the works, their prices may have increased substantially. So there's always a risk what you're allowing in your tender isn't going to be enough to cover yourself when they're delivering the works. The next source of uncertainty is productivity assumption. So this would be overestimating how fast crews can work. Then when it comes to actually doing the work, their productivities are less than what you anticipated for. Meaning your budgets for labor and plant are going to be insufficient. This might be because you haven't taken into account site access issues, weather, or the complexity of the task. The next one is subcontractor risk. So, this tends to be a bit of a problem in more building and commercial construction projects where you have a lot of really small contractors that go out of business and have high insolveny rates. So, that means you get prices from a certain subcontractor either before they sign the contract or as they're even delivering the work, they go broke. This leads to incomplete work. You having to take on other subcontractors at higher rates. The next one is specific site conditions. Now this is a bigger challenge in earth works and any sort of excavation activities where you have unknown ground conditions. You might have a lot of rock making digging much harder or you might have a lot of groundwater where you have to procure expensive pumps and dewatering systems. You might even have contaminated soil and have to pay a high cost to dispose of it. So this could

be higher excavation, earthworks, disposal, or compliance costs. The next source of risk are unfavorable contract terms. Now, you can say this isn't a risk. This is something you can just manage by reviewing the contract. But in my experience, the contracts construction contractors sign are always very onerous, and you can't negotiate away every single onerous term. It really comes down to your relationship with the client and how they enforce the terms of the contract. For example, liquidated damages in a lot of cases will never be enforced by a client. But if you have a really poor relationship with them or an incredibly aggressive client, they may choose to enforce these. They can enforce things like delayed payments, retention clauses, cashing your security. The risk is you're going to face cash flow issues and penalties that eat into your margin.

So now, the major sources of opportunity in any typical construction project. First one is value engineering. It's an opportunity you have when you start to get into the detail of planning your works that you can propose alternative materials and methods that help you reduce your cost. For example, there's a beam that you're going to have to do with expensive propping and temporary works. You could offer to do it as a pre-cast beam. Your client accepts it. You might be able to save a ton of money. So, there's always going to be value engineering opportunities if you put in the time and attention to exploring them.

The next opportunity is bulk procurement or supplier agreement. So this is where your business will be taking on multiple projects, will be procuring a large volume of a certain good, and across all their projects, they might be able to get discounted rates because they commit to working with one supplier. For example, your project might need 200 m³ of concrete, but the business might be procuring 10,000 m³ of concrete in the next 6 months. They could package this all up, go to a series of vendors, and get the best possible rates because of the big volume of work. There's always an opportunity to make buying gains with strategies like this.

Now, the next opportunity is going to be the opposite of the risk we spoke about before, which is higher productivity. Before, we spoke about lower productivities. We'll talk about higher productivities and efficient execution. This is when we get optimized sequencing, experienced crews, and we can really smash out the work. We might get favorable weather, minimal delays, and basically save a lot on our labor and plant costs.

Now, again, client relationships is a huge opportunity because it's the opposite of the risk I spoke about before with contractual relationships. This is where you build a good relationship with your client. You manage the contract not so much with letters and EOTs, but you're managing it as a personal relationship, and you get repeat business and lower risk of poor negotiations.

Now, the final one, which is very contract dependent. Some contracts actually have within them an early completion bonus to incentivize contractors to finish early. So if you have something like that and you can deliver the works faster, you'll be able to capitalize on it.

Okay. So, how do you include risk and opportunity in your estimates? Well, there's a couple of different ways you could do this. The first one is a percentage-based risk allowance. So this is where you add a flat percentage on top of the estimate. You could add 5 to 10%. It's simple, but it's broad. And it's better to use this when you're dealing with unknown unknowns. So these are things you couldn't possibly foresee. So you just want some broad project-level contingency that you can draw down on as you complete the works.

The second one is performing a proper risk buildup. So a bottom-up analysis where you go through every single risk in the project. You give it both a consequence if it occurs and a likelihood of occurring. And you actually calculate your risk contingency bucket. This is much more detailed, but what it's not going to cover is the unknowns unknowns. So, you're still going to need some sort of percentage-based risk allowance, but on top of that, you can have a detailed bottom-up analysis.

The final thing, which is my favorite strategy, and I think by far the best, is rather than focusing on pricing in risk, you focus on the terms of the contract. So, you exclude certain items from scope or qualify your offer or make it clear what your assumptions are based on. So instead of pricing these items and bidding yourself out of a job, you can qualify your offer and focus more on the specific terms and conditions.

Okay. So, so far we've calculated our cost. We've worked out uncertainty around this cost, and we've got a reasonable figure of what we think we're going to need to spend to deliver the project. Final thing we need to do is we need to mark up our cost to get our sell price. What are we actually going to bill the client for the work? This means we need to cover our profit margin to the profit generated for the business and any corporate overheads, costs we'll incur running the business that we can't directly allocate to a project.

So up until now, estimating has been largely a technical process. We've measured quantities, we've determined unit rates, and we've applied and analyzed risk. But when it comes down to profit and corporate overheads, margin of markup, we move into business strategy. Estimating becomes much less of a science and much more of a game. What is the maximum we can bill our client for and still secure the work?

So firstly, corporate overheads, what are they? Well, corporate overheads are costs you incur to run your business that are not allocated to a single project. So these are things like head office rent, admin staff salaries, accounting, HR, company vehicles, IT systems, insurance, marketing, legal, executive salaries, the cost of bidding more work. These overheads are typically recovered by allocating a percentage across all projects. So, for example, if your annual overheads are $2 million a year and you forecast $20 million of revenue, to recover your overhead costs, you need to put a 10% markup on all your revenue.

So, how do you apply these? You calculate a required overhead recovery rate, which will be a percentage, and then you apply this to your direct and indirect cost. And basically, you need to work out a rate that ensures your business is sustainable. If you can't cover your overheads, you either need to reduce them or you're in the wrong business.

Profit is the money you make after you've covered all your costs. It is your direct project costs, your indirect cost, so your staff salaries, your supervision, and your business overhead. So, the business running costs you can't allocate to a project. What you've got left over after this is your profit margin. Profit margins and the margins you put on it is a pure business decision. Some projects you could have a 50% margin and get away with it. Some you wouldn't be able to get away with a 5% margin. It depends on how much risk you're taking, how much competition you face, how much backlog you already have, and how much you want to secure this project specifically, and your company's financial goals.

When setting your profit margin, there's a couple of key questions you should ask. How much do you want to win the work? Are you desperate for the pipeline for the prospective project? Then you're going to bid with a lower margin. If you're a selective premium contractor, you only want to take on a handful of projects, then you can put in a higher margin. Next question is, how competitive is the market? Is it niche or specialized work? Then you can justify a higher profit margin. If there's huge amounts of competition, there's 20 contractors all tendering for the same project, then it's going to be a lot of pressure on your profit margins. The next question is, what margins do you need to be confident in doing the work? Now, when we're talking about risk and opportunity management, we spoke about unknown unknowns. There is always going to be a chance that your costs exceed your revenue. The way to minimize this is to have a higher margin on your cost. If you have a 50% margin, your estimate could be 50% wrong and you still make money. If you have a 5% margin, then you have very little room to move. So, high-risk jobs should require higher margins, and low-risk repeat clients where you know that exact type of work, you've got a really good cost library, you understand exactly how much this type of project costs, you can justify a much lower margin.

Okay. So, what are typical profit margins? Again, this is so location, project, work type of work dependent, but big contractors typically sit on a project margin of around 7 to 10%. These will be, so these numbers are profit and corporate overheads. Mid-tier contractors would be more like 10 to 15%, and specialty subcontractors would be getting around the 20% mark. Again, so estimating is the scientific approach to calculating cost. Profit and overheads are business decisions. They need to be made by business managers, people who understand the competition, the market, and the business strategy. Great estimators need to understand both. They need to understand the scientific approach to calculating cost, the objective side of estimating. They also need to understand the subjective side, which is the business decisions that surround pricing projects.

Okay, so now we've determined our sell price, what we're proposing to charge the client for our work. Final thing we need to do is we need to review our estimate. We need to check it's correct, comprehensive, and we're not going to lose money on this job. Then we need to submit it to our client and come up with a format that we can provide them our quotation.

So why is reviewing your estimate so important? Well, for the simple reason that underquoting jobs sends construction businesses broke every single day. Warren Buffett had a famous saying which was, "Never lose money." And you should 100% apply that in your tendering approach. It is always better to have no work than to lose money on a project. People say you should buy projects. That doesn't make any sense to me. If you structure your business in such a way that you have incredibly low corporate overheads, then there is no pressure to secure work at a price that there's every chance you lose money. To protect against this, you should review your estimate in detail and also structure your offer to make sure the terms and conditions align with what you've priced. That's the key to this step. Not just focusing on the price, but also focusing on the terms.

The first step in this process is to document and qualify. So, an estimate is only valid if it reflects what you believe the scope of the job is. Clients may have different expectations. That's why it's important when you're preparing the estimate to document what you're pricing and to qualify. This means clearly articulating in your letter of offer what's included in your price, what's excluded, so the scope you're not pricing, even if they've asked you to price it, and any assumptions. I like to go to the next level of detail where for every line item in the pricing schedule, I write a description of exactly what's included, what drawings I've referenced, and every single assumption and qualification that is relevant to how they would review the price.

Now, every estimate you submit, every quotation should be accompanied by a letter of offer or bid clarification sheet. This should include a scope summary. So, what's included in your price, your key exclusions, what you have not priced, any assumptions that your price is reliant on. So, any assumptions that you don't want to take the risk for, and the terms and conditions of your offer. So, payment terms, the validity of your offer, escalation clause, anything you want to cover like this.

What will typically happen with a construction tender is the client will send you a draft contract. Now, depending on how serious you are about winning the work, you might as part of your tender actually review this contract and come back with a list of departures. What I'm guessing is that if you're tendering a lot of work, you don't really want to waste time doing this until you get to the negotiation table, in which case you can then review the contract and get the terms and conditions of your letter of offer to align with their contract. To me, one of the most overlooked parts of estimating is terms and conditions. Your pricing is based on your understanding of the scope and the terms and conditions of contract. If the contract changes, if what you need, the work you need to do changes, then your price must change. Always align your price to your commercial terms, or you risk pricing for one thing and being forced to deliver something else.

So part of reviewing and submitting your offer is getting the terms and the price to align, but the other part is just fact-checking and studying your estimate to make sure nothing's missed. So first step in this process would be a detailed review. I apply the 80/20 rule where 80% of your costs will probably only be in a handful of items. For those big ticket costs, go through them line by line. Even do them again to make sure that the numbers you have are spot on. When you're doing this, the key areas to review critically would be any major cost items, subcontractor quotes, productivity assumptions, risk allowances, and your indirect costs.

Once you've completed your detailed review, you're confident with what's in the estimate, you think it's correct, you should then do some high-level sanity checks. So you could compare the total cost of the project. For example, if it's an earthworks job, you might do cost per meter squared. Or if you're building a solar farm, you might calculate a dollar per watt figure and compare it to previous similar projects or accurate estimates you've created in the past. And you just want to get an idea of, does the total price feel right? Are the buckets of money correct? And if not, to dig deeper and explore why.

The next thing I always like to check is review the scope. So, not putting the estimate aside, just looking at the work packages you've come up with, the work breakdown structure. Does it cover the entire project scope? Often what happens is people tend to price things correctly. The issue they have is that they miss scope. So, it's much easier to check, is all the scope covered as opposed to, have I priced everything perfectly? And then you can do mathematical checks. But again, this would be error checking the big cost items of your estimate. It's probably going to take too long to go through every line in your cost estimate to check the formulas are correct.

For labor and plant costs, a useful check you can do is to check that your costs are aligned with your program. If it's a big tender and you are preparing a construction program and you know you have a 20-week construction program and that you're planning on having six full-time workers on it, you can easily calculate from that your total man-hours, which should align with your bottom-up estimates. That's one of the easiest ways to check your labor and plant costs.

And the final one, which to me is a non-negotiable, is to get somebody else to go through and check your work. Not so much explain it to them, but to just get them, send them the estimate and get them to review it in as much detail as they want. That's why, this is a comment I probably should have made earlier, but that's why when you're actually preparing your estimate, it's really important to write notes and to set it out in a very clear and repeatable fashion. For example, your direct cost to have a template where you put all your quantities into it and then have a structured line-by-line estimate that anyone in your business can pick up and critically assess.

Now, once you've checked your estimate, you're happy with your terms and qualification, the final step is to submit it. Your final submission should include your summary of your estimate. So, this would be the client's pricing schedule, bill of quantities filled out. Your letter of offer detailing your assumptions, your exclusions, and your key terms and conditions. Any supporting documentation such as a bill of quantities, schedule, a program, and also any contact details for clarifications.

Okay, awesome work. That's it. That's estimating 101. We took you from understanding the fundamental principles of what is an estimate, what are they used for. Then we went through the process of calculating a detailed bottom-up estimate, calculating your indirect costs, putting on your profit margins, your risk, and then how to finally summarize and submit this to a client. Estimating, as I said in the beginning, is the make or break skill of construction businesses and is fundamental to the success of any business. Now, I said a couple times in there that one of the key things I think a lot of people overlook in estimating is terms and conditions. So, if you are keen to learn more, then check out this video next on construction contract administration. If you understand contracts, you're going to be a way better estimator.

A study by McKinsey found that eight out of 10 construction projects finished late. These were all major construction projects with experienced project managers and planners. So, given this, why do so many construction projects get delayed? The clients set unrealistic finish dates? The planners get the methodology wrong? And do the construction teams ignore the plan as soon as they start building? Well, yes. All these factors probably contribute. But the reality is project scheduling is super difficult. To build a good project schedule, you need to understand the project scope and the quantities of work. You need to plan the construction methodology and sequence it logically. You need to define task dependencies correctly, and you need to factor in resourcing across different tasks. Then to manage the schedule during the construction phase, you need to communicate and constantly refine the plan. You need to track progress against the baseline correctly. You need to predict issues before they become problems, and you need to adjust for delays, clashes, and resourcing issues. So, in this video, we're going to teach you exactly how to do that. We're going to teach you construction project scheduling. We'll cover what is scheduling and how it's actually used on projects, why scheduling matters, and how it makes contractors more money, the core scheduling concepts. Then we're going to cover in detail the core stages of construction scheduling and the one that everybody ignores. And then we're going to finish with some pro tips and mistakes to avoid. This is the exact scheduling system I use. It's a blend of boring critical parts scheduling, but also the best parts of lean construction and agile scheduling. Whether you're a business owner, project manager, project engineer, these techniques will work for you. And if you want to get the slides, I'll put a link to download them in the video description.

Before we dive too much into the content, we need to address the important question of how is scheduling actually used on projects. If you take any project management course or go through any project management textbook, they're going to tell you that scheduling is the most important skill. You need a 10,000-line Gantt chart to deliver a project. But the reality is that's just not how things happen on real-world construction projects. This is what we actually see happen. Starts with a client setting some unrealistic finish date. They say they want the project completed in the next 12 months. They then go to market. Three to six contractors quote to deliver the project. The most aggressive contractor, the one who's desperate to win the job, will say, "Yep, we can meet that." They reverse engineer the schedule and they come up with some completely unrealistic baseline schedule. They submit this schedule. They sign a contract saying that they'll meet the client's finish date. As soon as construction starts, the schedule becomes a reporting tool only. It's a tick and flick exercise, and it doesn't reflect how the job's actually being built. The actual decisions on site are driven by instinct, deadlines, and chaos. That finish date remains fixed, so the team throws money and resources at it to meet their contract completion date. Extensions of time claims are made and argued with pretty poor substantiation.

Now, I'm not saying that this happens on every single project. Sure, some projects implement scheduling beautifully, but most projects I've worked on, this tends to be the pattern you see, which leads me into the dirty secret of scheduling. You don't actually need a schedule to deliver a project. You need a contract. You need an estimate. You need quality assurance and compliance certifications, but the reality is you can deliver a project without a schedule. Lots of experienced construction project managers effectively run the job in their head. They know the methodology, they know the constraints, they know the resources, and they work backwards almost from their gut feel. And the reality is a lot of experienced construction managers actually do a fantastic job of this. I call it scheduling without schedules. Experienced project managers can visualize the full build sequence, the key constraints for risks and the resourcing they need week to week. They don't need Primavera or Microsoft Project to tell them this. But the problem is this tends to only work from there. So what's wrong with this approach? Well, it tends to fall over with scale. Does not scale with complexity, team size, and it's hard to delegate to other team members. Leads to missed tasks and clashes, mistakes, the inability to substantiate claims like EOT claims, frustrated stakeholders, and poor forecasting. So yes, experienced construction managers can run a lot of things in their head or using their own methodology, but the best project managers know how to use scheduling effectively.

Okay, this leads on to my next point which is why scheduling matters and how does it make contractors more money. So the number one reason is that it just gives you planning clarity. The best schedules take gut feel, experience, the knowledge of the most experienced construction managers and turn it into a plan that everyone understands and can follow. It's a famous quote by Dwight D. Eisenhower that "plans are useless but planning is essential." And it captures this idea that a plan that everyone can see, everyone agrees on helps to identify clashes, identify constraints, optimize the sequence of the build, and gives you smoother delivery. Better plans mean fewer mistakes, rework, and changes.

As an extension to this, it helps with communication and delegation. The schedule becomes the source of truth. There's a clear plan that shows who needs to be where and when. It aligns the project team, subcontractors, and suppliers with the baseline. The schedule is the source of truth. It helps answer questions like, "When do I need to be on site?" "How long do I need to allow for material procurement?" And that this is all captured in the project methodology and it helps to communicate this to everyone who needs to work. So, scheduling helps with coordinating delivering the project.

It's also a fundamental part of construction contract management, particularly with negotiating and getting claims approved. Contracts typically require contractors to maintain a program. So you have your tender baseline program you initially created, then weekly, fortnightly, monthly, whatever the contract says, you'll need to report on your progress against this program. Doing so will help you keep your client happy, but it will also help you be protected from liquidated damages by helping you to substantiate any EOT and delay claims. If you've got a program, it shows everything your client was meant to provide you. Maybe they were meant to approve the design by a certain date. If they're missing these dates, it's incredibly easy to claim delays and protect yourself from liquidated damages, but also easier to claim additional costs if you've been fairly delayed. Without a program, it's almost impossible to claim these things.

Now, a good schedule also helps you to manage the project stakeholders. I've already talked about the benefits of communication by having a source of truth in the schedule, but it also keeps your client and other key stakeholders happy. Makes you look professional, makes you look like you know what you're doing, and it also helps to set realistic expectations and timelines for when the project will be completed. It's an easy way to report on progress. It's an easy basis for progress meetings, and it's going to help reduce disputes because everyone can see the plan. Everyone can see the methodology. Again, there's a source of truth for everyone to agree on.

Next, scheduling helps you save money. So it helps you to optimize with smart resourcing such as avoiding downtime, having multiple mobilizations from subcontractors, clashes between work groups. Also helps you to better plan your methodology. It helps to inform decisions like whether to self-perform works or subcontract them. For example, if you have a long continuous run of work, it might be better to set up your own self-perform team. But if you have big pet peeves where you need a lot of work done and then downtime, it's going to be better to subcontract. You can use that same principle for whether you hire in plant or whether you've got consistent use of plant throughout the duration of the project. So you might choose to buy it and then sell it at the end of the job. Scheduling helps you really optimize your cost and come up with the best methodology and also just leads to less chaos and fewer cost blowouts.

Okay. So instead of just boosting your profitability by reducing your cost, scheduling also helps a lot with managing your cash flow. It helps you to align your payment claims with progress. It can be used to actually substantiate payment claims. Can also be used to forecast material and labor costs more accurately so you know when you're going to be spending money in the future so you can manage your cash in your bank. And it also helps you to avoid overordering materials or delayed deliveries, which can again impact your cash flow. More predictable cash flow, as any contractor knows, is essential to keeping a business running.

Look, in a lot of ways, scheduling can be a competitive advantage for your business because a lot of contractors just don't do a very good job at it. It's going to help you finish early, which is going to help you save money with higher margins. It's going to help you to consistently deliver, which is going to make you look better to your clients to actually get you more work in the future because it demonstrates your professionalism. And it's also going to give you confidence to scale.

Okay, so to answer this question, how does scheduling make contractors more money? How does it maximize their profits? On the revenue side, it's going to help you to deliver faster and to get paid what you're owed if your client delays you and avoid penalties and lost income by being able to claim for delays. It's also going to help you to limit your cost. It's going to help you to plan more efficiently, reduce waste, come up with the optimal methodology, optimize your resources, but also reduce your indirect cost. So if you finish the project faster, you're going to be paying less staff salaries, higher of equipment, higher of temporary office building. So you can see on both sides, revenue and cost side. Scheduling has a range of benefits.

So now we understand why we should schedule. Let's get into the guts of the technical side of the topic and begin by answering the question, what actually is construction scheduling?

Okay, so put simply, scheduling is just planning and managing when each part of the project happens. It's taking all the tasks and saying when each task needs to happen, what needs to happen before, and what can happen after. It's the process and tools we use to manage time. So there's two key things the schedule captures. It captures how the work's going to be delivered and when it's going to be delivered. So how is the methodology we're using to deliver our project. So it captures both mandatory linkages. For example, we need to order materials before we install them. But also discretionary linkages. So for example, do we want to use 10 crews to do this or do we want to use one crew and do it slowly? So that's the how, our methodology. And based on this, it captures the when. So for every task we need to do to complete our project, when is this activity going to happen? What's the planned start and finish date? What are the linkages? What needs to happen before? What can happen after? And what is the duration?

The output of this is the schedule. Nine times out of 10, it's going to be a Gantt chart. A Gantt chart is simply, as you can see on the screen, a list of activities, their duration, their planned start and finish dates, and then each activity is represented as a bar. So the bar shows when the activity starts, when it finishes. Then there's lines drawn between the activities which show the relationships to the following activity. So the Gantt chart is the document that captures our schedule.

The construction schedule lists all of the tasks, the activities we need to complete to complete our project. It shows the start and finish date of each task. It maps the dependencies between the tasks. So, what has to happen before, what can happen after. It highlights milestones, any critical deadlines, for example, our contract commencement date, our contract completion date, any milestones we have along the way, and it also identifies the critical path. So, that is the series of activities within our schedule. We'll explain this more later, but that if delayed, delays project completion. These are the series of tasks that determine our project's finish date. The schedule is then the plan that's followed during construction. So, we develop it during the planning phase. It's then our baseline for what we follow as we deliver the project. We refer to this as the baseline schedule. We update it during delivery and we also derive from it a whole lot of sub-schedules. For example, construction teams usually have some sort of 3 to 6-week look ahead that they use to plan and coordinate the day-to-day construction activities. The procurement team might have a separate procurement schedule that shows all the packages, when they need to be awarded, when the materials are needed on site, and will have some sort of daily plan. So all these are sub-schedules that get derived from the master project schedule, the baseline schedule.

Okay. So now you understand the idea of a schedule and the baseline schedule. Let's talk about some core scheduling concepts you need to understand. So the first one is an activity or a task, which is the base unit in the schedule. We have a list of tasks, a list of activities like placing formwork, steel fixing, pouring concrete that we need to complete to complete the construction work. Each task needs to have the following attributes. It needs to have a start date and finish date. It needs to have a duration and it needs to have dependencies. So every task will have work that needs to be done before and work that needs to be done after.

We also have milestones. So milestones are zero-duration events that mark key achievements. For example, you might have one for contract award, foundations complete, handover of the entire project. These are the deadlines that drive progress. These are the fixed dates that our stakeholders, our clients, these are the dates everybody cares about and the dates that everybody's working towards. So people usually don't focus too much on tasks. They set the finish dates, and these are the dates that actually drive progress.

The duration of an activity is the time an activity takes to complete. This is going to be based on things like the quantity of work you have to do. For example, if you have to do 100 m of trenching versus 1,000 m of trenching. The productivity. So whether you can do 50 m a day or whether you can only do 20 m a day. And the number of resources, whether you're going to use 10 crews or whether you're going to use two crews. Key concept with an activity duration is whether you have a production-based duration, which means it's purely based on the number of resources you apply to it, or a program-based duration. So some activities have fixed durations no matter what. For example, if you order steel reinforcement, it might have a 4-week lead time, or if you order an electrical transformer, it might have a 70-week lead time. These are referred to as program-based durations.

Now, resources are always a contentious issue when we talk about scheduling because it can add a lot of confusion to a schedule. But a proper construction project schedule is resourced. What this means is that there's the assignment of labor, plant, and materials to a task. For example, a trenching activity might have an excavator, an operator, and a spotter assigned to it. What this does, it helps to align the estimate with the schedule, but it also helps you to understand the relationship between tasks based on your available resources. This is a really core concept in scheduling and something that makes scheduling very complicated.

You can level resources or you can smooth resources. So leveling resources means you're avoiding overloading resources depending on the number of crews you have. For example, if you only have one crew and you've got all these tasks occurring at the same period of time, you would need to level your resources because you've only got availability of one crew. It's going to push out the durations of these activities. Smoothing, on the other hand, is where you spread work without extending project time. So, you optimize the usage of your resources to avoid delays. Okay? So you can see an easy visual explaining this. But say, for example, you can only work 45 hours a week, and there's all these tasks that come out of the schedule. In the first week, there's 60 hours of work, but in the sixth week, there's only 10 hours of work. Resource leveling is saying that we can only work a maximum of 45 hours a week. So we have to take some of these tasks where we've got more than 45 hours per week. We need to move them from week one into week two, from week two into week three. What this does is it pushes the duration of the project from week seven to week nine. Resource smoothing on the other hand is, without violating that constraint of 45 hours of work per week, it's taking the ups and the downs and it's turning it into a consistent 38 hours per week.

Next, the critical path. And I would say this is one of the most misunderstood terms in construction project scheduling. Critical path is the series of tasks that if delayed, delay project completion. It's the longest path of dependent tasks. Controls the earliest possible finish date of the schedule. And if you can delay the task without impacting the finish date, by definition, it's not on the critical path. And the other thing you need to understand is this isn't a scientific set-in-stone term. Often when we look at a schedule and something has, say you're talking about a 12-month project and it has two days float. Yes, theoretically it's not on the critical path, but practically it is. No schedule is accurate down to the day. So the idea that something has two days float means it's on the critical path. The other really important thing you need to understand is the critical path is dependent on resourcing. You can have critical path activities that are program-driven. So there's nothing you can do about the duration of the task. That's different to a critical path activity where we can adjust the resourcing and do it faster. So these are some of the things you have to keep in mind, and it's some of the things you have to understand when you're looking at a schedule, and it's where it really scheduling becomes as much as an art as a science to understand the actual data that's driving these program durations. When we talk about optimizing the schedule, trying to bring forward the completion date, the only way to do this is by reducing the critical path, working out how we can take tasks on the critical path and make them shorter.

Okay. So, if you look at a really simple Gantt chart, you can quite easily visualize on this what is a critical path task and what's not. For example, site preparation. If site preparation gets delayed, it pushes all the in-ground services back. Therefore, it's on the critical path. If we delay site preparation by a week, it's pushing out our finish date. Look at the next set of tasks, the in-ground services. You can see that the power in-ground services, if they get pushed back, they're going to push back excavation. But water services on the other hand, or the data services, we could push those back a week or two. It's not going to push back the excavation activity. So those activities are not on the critical path. They have some float associated with them. But if you do delay them enough, they will start pushing back the next activity, which is where we're going to talk about float.

Okay. So float is basically how much you can delay an activity before it impacts your critical path. Total float is your impact, how much you can delay an activity before it impacts the critical path. Free float is how much you can delay an activity without it affecting the next task. The difference between these two is if your next activity is on the critical path, your total float will be equal to your free float. If you delay the next activity, you're delaying a critical path activity. But if you delay an activity that's not on the critical path, then you have some free float.

Okay. Next, we have constraints. A constraint is any limit or restriction that affects how and when activities can be carried out in a project schedule. You can have a time constraint, for example, a deadline, a fixed start or a fixed finish date that you have to work around. You can have resource constraints, for example, you might have limited access to labor, plant, or materials. You might have a physical constraint, for example, due to site access, you can only have one entry and exit, which might impact how your deliveries go. Or you might have a certain number of days that it's raining where you can't work. Or you could have a contractual constraint, which might be some fixed contract completion date. So all of these are restrictions of how and when activities can be performed.

Okay. Next, we've got the idea of schedule optimization, which I brought up when we were talking about the critical path. But this is how we reduce the duration of the project by optimizing the schedule. By definition, the only way we can do this is by reducing the critical path. Critical path, the longest series of activities that we need to complete to complete the project. We have to reduce the length of the critical path to reduce the length of the project. There's two ways we can do this. We can fast-track activities, which is if you look at the diagram, that's where we overlap tasks. This adds risk because you introduce the risk that if task one has to be completed before task two can start, but you want to bring them forward. So you overlap the activities. There's more of a risk that task two will get delayed because they'll run out of work to do because task one's not complete. The other way we can accelerate the schedule is with crashing. So this is adding resources to accelerate progress, which adds cost to the project because you're adding more people. They're going to be working less effectively. You have to pay for more inductions. You have to pay for more onboarding. Generally, adding resources will increase the cost of the project.

Okay. Next, we've got activity linkages. The linkages between tasks define the workflow or the methodology. For example, we need to do the excavation. Then we can start the concrete works. We need to install the underground conduits before we can start pulling cables. The task linkages capture the methodology, how we're going to build the job. Key types of task linkages are mandatory. So, things that have to be done in sequence. For example, you need to order materials before you install them. Or you can have discretionary linkages. So these are choices in the way we do the work. Classic example is resourcing. We can have 10 crews or we can have one crew. That's a choice we're making that captures our methodology and how we're proposing to build the project.

Okay. So there's four main types of activity linkages we can have. The classic is the finish-to-start relationship. Activity A has to finish before activity B can start. We can have a start-to-start relationship. Activity A and activity B need to start together. Or we can have a finish-to-finish relationship. For activity B to finish, activity A must finish. Or we can have the least common, which always confuses me and every time I see an example of it, I get slightly confused, but it's a start-to-finish relationship. For activity B to finish, activity A must start.

Okay. So, let me give you some more concrete examples of these to help you better understand. So, the finish-to-start relationship is the most common one, which is task B cannot start until task A finishes. For example, task A might be pouring concrete. Task B might be structural framing. You need to finish the concrete foundations before you can stand the frames on them. That's a classic example. And that'll be 95% of the activities in our schedule.

The next type is a start-to-start relationship. Task B cannot start until task A starts. For example, when you start excavating, so say you're digging like quite deep foundations, you can start the shoring at the same time. So as you dig down, you put the shoring around the walls. So as soon as excavation starts, shoring can begin in parallel. So these activities would typically have a lag between them. They wouldn't start exactly the same time. You might start with a 2 or 3-day lag.

The next type is a finish-to-finish. So task B cannot finish until task A finishes. For example, if task A is installing a ceiling grid and task B is installing the tiles, for the ceiling to be complete, both tasks must finish at the same time. And by far the most confusing one is start-to-finish relationship. So task B cannot finish until task A starts. So say the only good example of this I've seen is that say you're decommissioning an old power system. So task A is to start your new switchboard. Task B is to decommission your existing switchboard. You can't turn off the old system until the new one comes online.

Again, there's this key concept of mandatory versus discretionary linkages. And this is really important to understand when you're creating your schedule because one of the biggest mistakes I see people make is they put in a whole lot of discretionary linkages, and their schedule becomes too complicated too fast. A mandatory link is something that must be carried out in order. For example, you can only complete the concrete pour once the foundation is excavated. It is physically impossible to do it any other way. Discretionary linkage is where tasks are sequenced to save money, optimize resources, or other benefits. For example, you might choose to use less resources and extend the duration of the project because you want to use less supervision. So that's an example of a discretionary linkage.

Now, you can have activities just finish and start as they come, or you can have leads and lags between activities. A lead time is starting a task before the previous task is fully finished. A lag time is delaying the start of the next task before the next one starts.

Another important term to understand is the baseline schedule. The baseline schedule is the approved plan. It's the contract schedule. It's what we said we were going to build at tender. It's what we signed a contract to deliver. This is the basis of how we're going to deliver the project, and it's going to be used to assess and track progress. So, we're going to report on progress against our baseline, and it's going to be used to assess variation. So if there's a change, the way we're working, change the completion date, always going to refer to the baseline schedule versus what we have currently.

Another important concept to understand is schedule levels. So schedule levels refer to the level of detail in the schedule. We have level one, which is the high-level master schedule, which is what the client will be seeing. It's just very high-level, showing key things like design, construction, commissioning, handover. Level two would be a package or area schedule where you've broken out, say construction, you've got it broken into earthworks, concrete works, structural works, and it's broken out into more detail. Level three is a target schedule where you break down again, say excavation into a couple of key activities with milestones, and this is where you sort of capture the interfaces between the different areas. Then below that, your level four to six schedules is the schedules the construction teams or the relevant disciplines use to plan out their work in detail. They might have a 2 to 6-month program, a 3-week look ahead, and then a daily plan. So a daily plan of exactly what's going to be done each day, which will roll up into your 3-week plan. So what are we getting done in the next 3 weeks? What's every single task we need to do? And this will be captured in your midterm program. But these all need to align with the level three schedule, the level two schedule, the level one schedule.

So I like to think of scheduling into two broad categories of activities. We've got development and we've got implementation. So development is where we

Create the initial schedule. It's where we create our baseline schedule of plan for how to deliver the work.

Implementation is then when we put this plan into action. A lot of people refer to this as monitoring control, but to me that's wrong. We're not just monitoring and controlling a schedule. We actually need to put the plan into action. The schedule baseline is our vital that tells us what needs to happen and when. We need to take this plan and we need to follow it. And if things change, we need to change the plans.

What happens so often on projects is people ignore implementation. They create this super detailed amazing schedule, put a ton of effort into it. Then when it comes to delivery, they just ignore it. So that's why I like to think of it not so much as monitoring and controlling but implementation taking the plan and putting it into action.

So development is creating a plan for how to deliver the project. Our plan is our project schedule. Tell us all the work we need to do the start and finish date of all the activities the durations and the linkages. What needs to happen before? What needs to happen after?

So there's six steps to building a schedule. Step one is to identify all the activities. What is all the work we need to do to deliver the project. Step two is to sequence the activities. We take these activities, put them into a logical order. We then estimate the durations, develop the model. So put all this together, the tasks, the sequence, the durations. It gives us our schedule model, our Gant chart. We then optimize and analyze this. Is it breaking any constraints? Are we running over our finish date? What do we have to change? And then we get feedback and input from our stakeholders to check that everyone's happy with it. Makes sense. It captures how we're going to deliver the project. And then we've got implementation.

So building a plan and doing nothing with it is pointless. It's a waste of time. But it happens all the time in constructor. People spend so much time planning and then they do nothing with their plans. The only value a plan has is when it's followed. So schedule implementation is putting the plan into action.

So how do we put a plan into action? We need to understand and interpret the initial plan. We need to take our master project schedule and we need to work out what's going on. What do we actually have to deliver? We then take a chunk of this our scope of works what we need to deliver and we develop a short range program. So depending on the type of project you're doing, this might be a 3we look ahead. This might be a three-month look ahead. We then focus on our enablers. What do we need to get ready? What do we need to have in place to deliver the project? We then manage our lead times. We look ahead far enough. How far ahead do we have to order materials? We get everything ready in time. We then track and monitor. We look at how much work we're getting done, what the plan's telling us. What do we need to change? And if things are deviating from the plan, we implement corrections. Don't worry, I'm going to cover all these steps in a lot more detail in just a second.

So schedule development is how we build a schedule that complies for the project requirements, captures the construction methodology, optimizes the construction methodology, so comes up with the best solution both in terms of cost, time, safety, quality, factors in our constraints, so limited resources, access to site. It's easy to understand and follow and it can be used as a tool to manage the construction work. So the schedule we develop has to tick all of these boxes.

So the first step in this process number one is we need to identify all the activities. This is creating our activity and task list. All the tasks that need to be completed to complete the project. We do this with our work breakdown structure which is our hierarchical decomposition of the project scope. We take the overall project scope. We break it down into component pieces. Now our activity list is going to be a function of two things. The scope of the project, so the drawings and specifications, what we need to do, but also our methodology. So our methodology is an important factor to consider when we're creating our work breakdown structure. We're going to make important decisions around how to deliver the project which will actually influence task list. For example, are we going to use pre-cast concrete or we going to do insitue concrete works? Can we get stuff fabricated off site? We're going to build it on site. We're going to break an area down into four separate areas and have four separate crews in it or we just going to have one big area. A lot of the steps we go through when we create our work breakdown structure are going to be driven by the methodology we choose.

As an example, the work breakdown structure for a road project. So, this is what we need to create for our project before we can begin building a schedule. A road project we might break down into earthworks, structures and bridges, utilities, and road works. Under each of these tasks, we then break them down into another level of detail. For example, earthworks. We could break down into clearing and grumbing, bulk earthworks, drainage, and subgrade preparation. Our utilities might be broken down into services, installations, street lighting, traffic signals, utility relocation. So each of these tasks then break down into another level of detail. Again, within the utility scope, we had street lighting. So street lighting we could break down into the pits, conduits and foundations, the lighting poles, the distribution boards, the power supply boards and the circuits and luminers. From this level we can then create our list of work packages. Work packages are the tasks in the schedule. To create our actual work packages, we've taken the project and we've broken it down into three zones. So pits, conduits and foundations. We've got zone A, zone B, zone C, zone D. We've done this for all the different tasks. Pits, conduits and foundations, lighting poles, distribution boards, circuits and luminers. Based on this, if we were turning this into a schedule, we would have a task in our schedules for pits, conduits and foundations in zone B. We'd have a task in our schedule for the circuits and luminires in zone C. So, this is our work breakdown structure dictionary, our task list for the project.

So, when you're doing this, I just want to stress the point that methodology is an important input to creating your task list. For example, you might have a 200 m cubed concrete slab. You could do this in two pours or you could do this in one pour. Depends on whether you're going to add a construction joint or not, whether you're allowed to, whether you can get approval from your client. If you have two pours, obviously have to reflect that in the schedule. You have one pour, your schedule will look different. So, actually, how you choose to build it will impact your total task list.

Again, as an example, let's build a really simple schedule for this concrete slab. So you can see this concrete slab here. We're going to break it down into a series of tasks and we're going to start entering it into a Gant chart. So we got this concrete slab. We can see it's a 100 mil thick concrete slab. There's a series of ground beams. Review the drawings and we look that you can see with the ground beams. There's no construction joints between the beams which we can assume we can pour the whole thing at once. So I'm using a simple Gant chart software for this. So first thing we have to do, we have to identify the tasks. Let's do we'll break it down into initial and concrete. So we've got mobilization, bulk earth works and materials. So these are three tasks that have to be done before we can start works. And then for concrete. So once these are done, we can actually start the concrete works. Got detailed excavation. So this would be excavating for all the ground beams. We'd have formwork. So this is putting the formwork around the edge of the slab. We'd have steel fixing. Just call that formwork placement steel fixing concrete pour curing. You could show this as a task or a lag. We'll show it as a lag. So we'll add this later. Concrete pour formwork strip. They are all the tasks in our schedule. Our work breakdown structure is really simple. So we've got this set of tasks under concrete and this set of tasks under initial.

After we've defined all the work we need to do to complete the project, what we have to do next is to put them into sequence. Now understand that this happens iteratively. We go through, we find the task, we put them in order, we realize we miss some tasks, we go back, we do it, understand happens iteratively, but laying it out as a six-step process, it's just an easy framework to think through it. So next we're going to talk about how to sequence the tasks.

So sequencing the task is capturing our methodology. It's putting the work in the order it needs to be done. What needs to be done before a task and what can be done after. This is referred to as the network schedule. You don't have any durations as the tasks and linkages. We also want to introduce our leads and our lags. So, for example, after we pour concrete, how long does it need to take to cure? These are our leads and lags. And we've already spoken about the different types of linkages. Our mandatory linkages, what has to be done a certain way, and our discretionary linkages, choices we're making about how to sequence tasks. Now, my really strong recommendation is when you do your first cut of the schedule, just focus on mandatory linkages. Big mistake I see people make is they do both at the same time and it gets really confusing. When you do your first cut of the schedule, keep it simple. Just do the mandatory task linkages.

Okay, so let's take from our example road project, the work breakdown structure we had in the last section. Let's break this down into a network schedule for the street lighting activities in one zone of the project. So we can start the street lighting works, the pits, conc, and foundations once the earth works are complete. So we've got a milestone in our schedule for earthworks completion. Because the foundations have a 5-day curing time for the concrete before we can start standing the poles, we have a 5-day lag before we can supply and install the street lighting poles. We then can also supply and install the distribution boards. And once these are done, once we've installed the poles, we've installed the distribution boards, we can start installing and terminating our cabling. And the completion of this, we've got our street lighting in zone A complete. This that's the general methodology of how they we're going to do the job. We have to do the pits, commutes, and foundations first. We have to wait for the concrete to cure. Then we do our poles, install our distribution boards, and then we can install our cabling.

Okay. So, for our concreting project, let's go through and do the same thing. So, our initial tasks are going to have no predecessor in them. They're just going to be the start points of our schedule. So, we have no predecessor. We'll just give it a fixed start date. So let's give it today's date 12th of May 25. Same with our earthworks and same with ordering our materials. These are all going to start on the same date. They're going to have no lag between them. What happens next? So the first thing we need to do is we need to do our detailed excavation. So for that to be done, we need to mobilize the site and we need to have done our detailed excavation. Remember, we're putting no durations in yet. So we're going to go through and fix up these durations in the next section. Then we can place our formwork once we've done the detailed excavation and we can start the steel fixing at the same time. So, so steel fixing formwork start at the same time. Once our steel fixing and formwork's done, we can place our concrete. So, we need seven and eight complete to the concrete pour and we then can strip our formwork once we've done that. Importantly, but when we pour our concrete, we have to wait for it to cure. So, we have to wait. We have to introduce a lag. So, we got four strip and we're going to introduce a 5-day lag to allow for the concrete curing. I think I've done that wrong. Ah, sorry. It's that wrong task. So, I make that concrete pour with a 5-day lag. And that 5-day lag, you can see here that is the concrete curing time. Once that's done, the tasks are good.

Okay. So, we know the tasks, we know the order. The next thing we need to know is the duration of each task. We have to estimate from start to finish how long each task will take. Now this is going to be a function of the activity itself, the nature of it and the resources we apply to. Remember at the start we spoke about the difference between a production-based task which is purely driven by resources and their productivity and a program-based task which has some sort of fixed set duration. We also need to consider whether we're self-performing a task or whether we're subcontracting a task. So that's going to impact how we go through the process and estimate the durations. We also need to consider the calendar. So the calendar is the days available to work. Are we working a 24-hour shift? We're doing night shift. Are we working Monday to Saturday or only working Monday to Friday? Are there a ton of public holidays coming up? So on and so forth. So we need to consider available working days.

Okay. So when we're estimating the duration of an activity and it's a production-based task, it depends on a quantum of work. So say we have 1,200 m of trenching to do. We then need to know a productivity per. So for example, 40 m per shift which is going to be driven by the resourcing we allocate to the task and the task itself. So whether we're going to have 100,000 or one crew that's going to give us the total number of shift that task going to take. So if we have 1200 m of trenching, 40 m per shift, we're going to take 30 shifts to finish the task.

Now, if we're self-performing a task, so using our own labor plan materials, we need to do a bottom-up estimate to determine how long the task will take or we can use benchmark information from other projects. The key is we're using our own labor plan and resources. So, we need to come up with the productivity rates. Now, on the other hand, we might be subcontracting out a task, which means engaging an external contractor to complete it for us. Subcontractors will have agreed upon programs in their contracts which we can use activity durations in the agreed upon programs to estimate. Then we can independently check and verify this using a bottom-up estimate or a parametric estimate. But when we're subcontracting a task, we'll need to take the subcontractor's program of works and integrate it into our own.

Now when we did that calculation of 1200 m of trenching, 40 m per shift gives us 30 shifts. That's not the actual duration of the task. That's the number of shifts it will take. The schedule calendar is going to help us determine the start and finish date of the task. Are we working 6 days a week? Are we working 5 days a week? Public holidays, night shift, all these sorts of things captured by our schedule calendar.

Okay, going back to our street lighting example. Say we have civil self-perform work. So, we're managing work ourselves, an electrical subcontractor doing the light poles, installing the distribution boards, and doing the cabling. Let's work out how we work out how long this task will take. Okay, so for our civil self-perform works, because we're self-performing the works, we need to do a bottom-up estimate. So we're looking at the working hours for the day. Say it's a 10-hour day, and we're allowing for 3 hours of non-productive time. We've got pre-start, we've got lunch breaks, we've got setup, pack up, these sorts of things. So we get really 7 hours a day when we're working. AU know a crew from past project data can install 20 m of conduit per hour. This equates because we've got seven productive hours per shift. This equates to 140 meters per shift. For our pit installation, a crew can do half a pit per hour. So, it takes them 2 hours to install a pit. And for our foundations, again, they can do half a foundation per hour. Takes them 2 hours through a foundation. So, we can do 3 and 1/2 foundations per shift and three and a half pits per shift. Now, we also know the total volumes of work. So, based on these total volumes of work, we can come up with a total number of shifts. So we've got 25 shifts for the conduit installation based on 140 m per shift, 40 shifts for the foundations and 10 shifts for the pit. So this is just based on total quantity of pits and foundations. And this gives us a total number of shifts for all these tasks. So we need 75 shifts of work to complete the civil works in zone 8.

Okay, let's go back to our example. Schedule the concrete foundation. So I'm not going to do quantity takeoffs and work this out, but this is how you'd have to do it. You'd have to say detail excavation there's 100 m cubed of soil to move. We can move 20 m cubed per shift. So it'll take five shifts. That's the type of calculation you have to do. You do these calculations and then you enter the durations into the schedule. And since we've already put in the linkages, it'll fix the task. So formwork, we say say there's like 100 m squared of of formwork and then we're going to put four guys on it and it'll take three shifts to do the edgeboards. Steel fixing, there's 20 tons of steel. It's going to be two guys on it. It's going to take um four shifts. So, as we put in these numbers, you can start to see that our schedule's actually coming to life. So, we got the concrete pour, which concrete pour will take one day, and then the formwork strip will take 2 days. Based on this, we've actually created our schedule model. So, we know the work's going to start on the 13th of May, and it's going to finish on the 4th of June.

So once we've got our tasks, our sequence, our durations, we put all this together. We get our schedule model, our Gant chart. These are our activities displayed against time represented by a bar chart. They show the activities, the plan start and end dates, the activity durations, and the start and end dates of your overall project. So you can use the traditional way of doing it by hand. But the reality is in 2025, you're not going to be doing that. You're going to be using some sort of software tool to create your schedule model. It's really a couple of different tools we've got at our disposal. I'll categorize these based on what typically project engineers or construction people would use. Then you've got specialist software that planners and project scheduling professionals tend to use. So for project engineers a lot we'd use Excel to do something like this. This might just be listing out your tasks and shading them to represent the bar chart to the Gant chart. And we use this a lot for things like a 3we look ahead or short range programs. Slightly more concept like a six week look ahead or a mid-range program. You might use something like Microsoft Project. I use Smart Sheet because I just find it way easier to use the Microsoft Project. As a project scheduling professional though, you're probably going to be use something like Primavera P6 which would have your master project schedule might have thousands of lines on it for a big project or the same with Inate as another proper project scheduling tool.

Okay. So once we've developed the model, once we've put that information into project or a similar tool, we've got our Gant chart. The next thing we need to do is we need to optimize and analyze it. Need to look at the critical path. We need to work out if it's violating any constraints. So the key question we need to ask here is the schedule going to meet the objectives of the project does it fulfill our requirements. So we need to ask questions like are we going to meet the finish date? Are there any interim milestones we need to consider? What is the critical path? Which activities have float? Can we optimize resources? Are there ways to minimize and reduce risk? And overall we kind of come to the conclusion is the schedule correct for our project?

When we do this analysis, we're really going to be looking at the critical path and asking the question, is the critical path correct? Because at the end of the day, that is what is determining the duration of the project. That is what has to make sense and be correct. You can be wrong about some activities that have more float. Ultimately, it's not going to have much of an impact on the contract you sign with your client. The critical part's wrong. If you have incorrectly calculated how long the project will take, it can have big consequences. That's why when you're doing this analysis, you always want to first look at the critical path and ask yourself, does it make sense? Is it correct? Are the activity durations correct? So often when you look at a critical path, the project, there's something the schedule model is telling you, but you just know that the information it's giving you, the result it's giving you is wrong. It just doesn't make sense that in reality, this would be the critical part. The biggest issue tends to be that resource estimates are either conservative or too aggressive. That's what tends to be wrong. When you look at the critical path, you see it and you realize like this isn't actually what would delay the project. We'd add more crews to this task.

So then when we're coming to the question of how do we optimize the schedule, there's really two principal things we can do. We can come up with a smarter way to do things or we can spend more money and have risk. When we're talking about coming up with a smarter way to do things, we should do this for all activities. We should always be questioning ourselves and asking, is there a better way to perform the works? The other hand, if we're talking about introducing risk and spending more money, we should only be applying that to critical path or near critical path task. Remember, the critical path is a calculation on a year-long project. If a task has 10 days float, less than 10 days float, for all intents and purposes, it is on the critical path. Your schedule isn't going to be accurate to the day where so you can confidently say that this isn't on the critical path. If it has less than 10 days float and it's like a year-long project again it depends on the overall duration proportionate to the level of float. Critical path near critical path in my opinion the exact same thing. So as we spoke about when we were defining these scheduling terms for these critical path or near critical path tasks, we can crash them. We can add resources to them that's going to increase our cost or we can fast track them. We can overlap them which introduces risk.

Okay. So the important final step in developing a schedule is to get our stakeholders to review it. This is going to really tie into when we talk about implementing this schedule, but we don't want to just build a schedule in isolation. And we want people to give us feedback. We want them to tell us what's wrong, what's right, review it, pick up errors we've made. Basically, get the whole team on board to get everyone to say, "Yes, this is the plan. We're going to follow to deliver the project." The other way to think of a stakeholder review is just getting their buy into the plan. You want people to say, "This is my plan. Yes, we can achieve it. Yes, we are happy with those dates. We're happy to meet them." A schedule is completely useless if nobody follows it. You need to ensure the plan is realistic, people understand it, and that people own it. They've given it their ticket of approval, they've given their feedback into it, and they say they're willing to help achieve it.

So, up next, my favorite topic in project scheduling, and the one everybody ignores, schedule implementation. Schedule implementation, put simply, is the process of turning our plans into action. We've spent schedule development building a schedule, creating it. Next thing we need to do is we need to turn that into a series of tasks that we perform to complete the project. Time and time again in my career, I've seen people put all this effort into building fancy schedules. They've spent hours working on them. They workshop them. They've done all this stuff. And then when it comes to actually delivering the project, as soon as it starts to get a little bit chaotic, they throw the schedule out. They put it in the drawer. They never look at it again. And then the project becomes a disaster. All that time they spent building the schedule, thinking through everything suddenly becomes wasted. The core message is that planning without action is a form of procrastination. It's a complete waste of time. So if you're not even going to bother following the schedule, why did you spend all the time building it to begin with? So when we really dig deep and think about it, the only value a schedule has is when we follow it. Sure, it helps us to assess feasibility and cost, but the real value in a schedule is to help us deliver the project. It's pointless to develop a schedule if we're never going to implement it. So schedule implementation is all about putting the plan into action. It's about planning, coordinating, and delivering the works in accordance with the original plan. It's the process of executing the plan laid out in the master schedule.

So we're going to take the high-level project schedule we developed the master schedule to implement it. We're going to break it down into clear detailed actions. We're going to take the schedule and turn it into a list of tasks we need to complete a to-do list. The goal is to make the schedule usable on site and turn it into a real-world setup of actions. A to-do list that we simply follow to put the plan into action.

Step one in this process is to understand the schedule. Now remember on most projects say we're in the construction team or the delivery team we probably didn't deliver or develop the schedule. Sure if we were lucky enough to work on tender and then move into construction we would have but a lot of the times we'll be thrown into a project and the first thing we need to actually do is to understand the schedule. So this will be reading analyzing and interpreting the schedule. When we do this we want to be hyper critical. We want to understand everything in detail and we also want to pick up all the mistakes and gaps. We'll typically get something like this. A whole lot of tasks with start and finish dates red to represent the critical path. When we're onboarding ourselves onto a project, we need to understand the drawings. Need to understand actually what we're building. Then the next step will be to look at how the drawings are mapped to the schedule, what we're building and how it relates to the plan. What's the methodology? What's the proposed resourcing? And we do that by analyzing the schedule. So the reason I said originally is that we want to be hypercritical when we do this is because schedules are always wrong. There's always things missing. There's always activity and linkages that are wrong. There's constraints or circumstances that have evolved that weren't there when the schedule was originally developed. There'll be detail missing and have been changed. So when we're going through the schedule, we want to understand that this was the plan, but it won't exactly match reality. We need to be hypercritical and to understand what is potentially changing. Your job is to question everything. Be hypercritical. Understand the logic. Again, at the end of the day, your job is to achieve the project outcomes, the finish date in the contract, the time the project needs to be completed by, not to follow the schedule. Your job isn't to blindly follow the schedule. It's to understand it, understand the logic, and pick up any errors in it.

The next step is that we want to decompose the schedule. We first understand it, then we decompose it. We want to the master schedule that's developed will generally be relatively high level. It'll have a start and finish date for trenching, an access date, and a completion date based on high-level productivities. When we're talking about implementing a schedule, we need to break it down into specific activities and tasks. These tasks will be more detailed than what was in the master schedule and we're breaking it down into more detailed schedule levels. We capture this in a short-range program. So a short-range program is a highly detailed short-term schedule that we use to plan and coordinate all the minor activities that needed to facilitate the works. We could use something like like an Excel document, a whiteboard, or even markups and staging plans. We use some sort of time slice method to do this. So we'll have a window of focus might be 3, 6, 9 weeks depending on the project and I'll talk about how exactly to determine this time slice you need to choose and then we take the t the task and the master schedule and we need to break them down into extensive detail into every minor thing that needs to happen to ensure that finish date for the task is achieved. Let me give you a quick example of what I'm talking about. Say in the master schedule we have basement excavation. That's a task with a start and finish date that probably won't capture any more information than that. We know the start date of the excavation and we know a planned finish date that the planner developed probably based on quantities and assumed productivity rates. The 3-week look ahead, 6-week look ahead depending on the time slice we choose needs to capture every single activity that has to happen to ensure the basement excavation is completed by the date. So this means floating the machine to site, getting the surveyor to mark out all the depths of the excavation, setting up barricades and temporary fencing around the excavation, excavating to the first design RL, then setting up shoring. So every task that has to happen will be captured in our 3WE or short-range program. Now when you're doing this, you're going to add a significant amount of detail. The only way you're going to know exactly what this detail is is if you have a really solid understanding of the construction methodology or more likely you have access to people who understand what's involved in the works. You need to understand the methodology in detail. List turn the tasks into subtasks that will all have their own dependencies and linkages. Now you might not capture this in a formal Gant chart or schedule might just be an Excel list. You need to understand the overall task is going to be broken down into 20 or 30 subtasks and all these tasks relate to each other as well.

Now, let me give you a really simple three-year heads for some street lighting, civil work. So, we've got trenching and pit install for a certain range of the road. And then there's tasks allocated to this. For example, they need an excavation permit. They need service proving to identify underground services. And there's a planned start and finish date. We're also going to have quality assurance and testing. So, testing the conduits, checking they're all installed correctly. We have another crew doing that. We have a crew doing the road the road crossing at John Street. Again, they need an excavation permit and there's a planned start and finish date. And we're also going to be installing light poles on the bridge where they need a lifting permit. So, we've mapped out the task, the permits we need, who's doing it, whether they need traffic management or a road closure, and the plan start and finish date. Now in our master schedule there might only be one line item in the schedule which says street lighting civil works in zone 2. Now through look ahead has broken this all down into detail.

Now the obvious question when we're doing this is how do we work out what all of our subtasks are? Well that comes down to pull planning. So pull planning is a tool where we ask ourselves before any task that's coming up, what is everything that needs to be in place to facilitate this task and it helps us to transform our schedule into a to-do list. So let me give you an example. If we're talking about the master project schedule showing a certain concrete structure, so a planned concrete pour, let's think about everything that needs to be in place to facilitate this concrete pour. We need the excavation complete. We need the survey set out. We need any service penetrations within the slab installed. We need the materials to do the work. So, we need temporary materials like formwork and consumables. We'll need the steel reinforcement. We'll need the concrete supply booked in. We'll need a subcontractor to complete the works or our own internal labor if we're self-performing the task. We need safety documentation and we'll need quality documentation. That is a list of things we need to get ready to complete the concrete pour on the fixed date. None of this will be in the master schedule. The master schedule will just show the concrete pour.

Now, so before I mentioned a 3-week look ahead is an example of a short-range program, but I also made the comment that the time slice you choose for your short-range programs depends a lot on the task. Now, all these different activities, ordering the materials, getting the subcontractor on boarded, all these things take time. So, this leads to the point of how long should your short-range program or your detailed to-do list be? And it really depends on how long this stuff takes to get ready. Depending on the type of project, it might be really quick. If it's a more complicated project where you've got longer lead times for materials, you might have to be looking 3 or 4 months ahead to ensure things stay on track. So, this is the idea of activity lead times. So activity lead times are basically just the time it takes to organize everything before we do the work. We need to consider for example the concrete the materials we need for the concrete foundation. We'll need steel reinforcement. So we need to allow for time to get it fabricated. We need to allow for time for the rebar supplier to get shop drawings and steel reinforcement. We need to get those reviewed and approved. We need to actually award a contract to them to supply the materials, which means we need multiple quotes and to go through some form of procurement process.

Okay, so let's imagine we have a concrete pour on the 28th of June. For this concrete pour, amongst the 20 other things we're going to need ready, we also need the steel reinforcement on site, which means if there's a 3-week lead time for the steel reinforcement, we need to award the contract and place the order by the 7th of June. If we need to allow four weeks to get quotes, to negotiate rates, to get internal approvals, to sign off the contract, we need our quotes back by the 7th of May. So, 1 month before that. If we need 4 weeks to review drawings, do our quantity takeoffs, prepare our tender packages. That means we need IFC drawings that tell us what steel reinforcement we need on the 7th. So, that's just one example of one chain, which is to procure it. So you can begin to see how far ahead you need to be planning to ensure a concrete pour on the 28th of June isn't delayed. Now depending on the project, these dates will change, but the example of the concrete pour, you need to be thinking about a June concrete pour as far back in April. Now I've worked on solar farms where we've been ordering transformers that have a 70-week lead time. So the core message I'm trying to give you here, you need to be really planning far ahead to be allowing enough time for all this stuff to happen. Again, the core message, think about what needs to be in place for the activity to happen and how far in advance you need to be getting that stuff ready.

So the core process I've spoken about here is to decompose the master schedule into a series of subtasks. You do this by identifying all of the tasks that need to be completed for the activity in the master project schedule to be completed. And to do this effectively, to make sure the master schedule isn't delayed, you need to understand how long this stuff takes to get ready by understanding activity lead times. So at the end of the day, schedule implementation is where scheduling meets time management. So much of scheduling implementation is just being organized, preventing roadblocks before they occur. Thinking through what has to be in place for this to happen. Constantly asking yourself the question, have I identified everything? Is it ready? Is it going to be ready on time? Effectively, what you're doing in this step is you're taking your schedule, you're transforming it into a to-do list. This might be done in Microsoft Planner, but I've always found with schedule implementation, you don't really want a complicated Gant chart. You just want an Excel document, a to-do list, a whiteboard, something really simple that the team can see and everyone can be working back from.

Okay, so we've taken the plan and we've worked out how to put it into action. Next question comes up is how do we know we're sticking to the plan? So that's why this next section we're going to talk about monitoring and controlling the schedule. How do you ensure you're staying on track? Now, there's a lot of different ways people express the monitoring control process. I like to think it of asking a question. How do we ensure we are following the plan? Schedule development. We built a plan. Schedule implementation. We took that plan. We turned it into a to-do list. We started working through all the actions to put the plan into action. Monitoring and controlling is then the process of checking that what we're doing matches the original plan. And if it doesn't, updating the schedule and addressing variances.

Now, when we built the schedule, there were assumptions. There were guesses. There were unknown and unknowable things. And that's just the reality of construction projects. Every single construction project is different. Every project is unique. When we're planning the projects, there are things we cannot foresee. There's changes that will happen. There's unknown and unknowable things that will happen. So, by monitoring, controlling the schedule, progress tracking, we need to keep the plan relevant and useful. It'll help with managing our stakeholders and it helps us to identify issues and deviances early. So fundamentally monitoring and controlling the schedule means tracking progress comparing how much work we're doing versus what our baseline plan is understanding deviations from this plan. And understanding delays and then when there are are delays applying treatments to them effectively monitoring controlling the schedule helps us to ensure the plan is still useful and relevant. It helps to ensure it still remains a useful planning and coordination tool. It helps us to then plan activities, book resources, and make informed decisions about cost, time, and scope. And if the information in the schedule's wrong, if it's not updated, then it can't be a useful tool that helps us do this.

Now, let me work through an overly simple example, but it's here to illustrate the point of why you want to keep the schedule relevant and useful. Say cable installation begins after the conduits are complete. The conduit installation is currently at 10% complete, but it should be at 90% complete. Looking at our schedule, our cable install is planned to start next week, but cable procurement has been delayed and everyone's stressed because the cable's not going to be here in time to start installing it. We've got an option to pay for an expedited delivery. The question is, should we do it? Well, looking at these numbers, obviously not because you can see the conduit install is only at 10% complete, even if it was meant to be at 90% complete. If we're updating our progress, tracking our numbers, we can clearly see the cable installation activity that's planned to start next week isn't going to happen because the conduit installation is so far behind. The question, should we pay for an expedited delivery? Obviously not.

Okay. So schedule helps us to make informed decisions around our progress and planning and coordinating the works, but it also helps us to manage our stakeholders. The schedule's used to inform our stakeholders of progress becomes the source of truth they can look at to see where everything's up to. Often it's also a contractual requirement to maintain a schedule written into the contract we have with our client that we'll need to provide them fortnightly or monthly progress updates. The schedule is how we capture realistic information. How far we're through different tasks like procurement or what percentage we're complete we're on piling.

Now the final reason we should monitor and control our schedule and keep it relevant is it gives us a way to look into the future. It's a lead indicator helps us to know if something's going to go wrong before it goes wrong. This is the opposite to a lag indicator where something goes wrong and retrospectively we can look at it. So, a lead indicator is a way of seeing into the future and preventing mistakes before they happen. As an example, say we know our piling is 10% complete at the end of week one and our schedule has a 4-week program for piling. It's a critical path activity. So, any delays to the piling will delay project completion. What should we do? Well, clearly we're going to delay project completion because we're 10% complete and we should be around 25% complete. We could look at options to do weekend work. We could look at options to do night shift. We could look at options to bring in another piling rig. The only reason we know that is because we understand the schedule. We know it's a critical path task. We know it's 10% complete at the end of week one rather than 25% complete because we've tracked progress and we've maintained our schedule.

Okay. So, the first part of scheduling, monitoring, and controlling is progress tracking. Progress tracking is basically just determining the percentage complete of each task in our schedule. And it's a really simple process. We first need to understand the activity we're tracking. We need to set up a progress tracker. And then we need to monitor the activity and record the actual quantities of work complete.

Okay. So first when I say we need to understand the activity we're tracking, we really want to understand whether it's a production driven task or a milestone driven task. Production driven task means the activity can be represented by a baseline quantity. The progress for the task is the quantity of work complete. For example, if we know we need to do 10 km of trenching and we've done 500 m of trenching, we've done 5% of the work. For examples completed verse the total numbers of piles. A milestone-driven task on the other hand is an activity that is a group of different sub activities where there's no consistent metric we can use to track them. Classic example of this would be procurement. You're not going to track the number of words of a scope of works that someone's written. It's just a series of different tasks grouped together. So you might have writing a scope of works, issuing the tender, getting quotes, contract award. You track these by giving fair representations of the work to each of the sub activities and tracking whether that sub activity is completed.

Okay. So if we want to set up a progress tracker for a production driven task, we want to determine the activity to be tracked. We want to determine the total quantity of that work from the design. So for example, we've got we're tracking trenching. We've got 10 km of trenching. Then we want to determine the start and finish date for the activity to give us a daily quantity or weekly quantity we need to be completing.

Okay, let's do an example for street lighting civil works. We want to track the percentage complete of the street lighting civil works in an area. However, we run into the challenge where we've got three different tasks for tracking. We've got pit installation, conduit installation, and foundations. The metric we want to track is linear meters of conduit installed because that's the biggest task. We could say for example we could have tracked the overall task by the number of pits or the number of foundations but in this sense made the most sense to track by linear meters of conduit which means we have to represent pit installation as equivalent to 20 m of

Conduit. This would be done based on, say, if a pit takes 4 hours to install and 20 m of conduit also takes 4 hours. We could just baseline it like this. Again, we're saying a foundation is the equivalent of 60 m of conduit. Okay.

So let's come up with a total quantity of work we need to track in zone A for the pits, conduits, and foundation. So, conduit install, we've got 3,500 lineal meters. Pits, we're saying we've got 35 pits, which is the equivalent to 1,500 m of conduit. And we've got 140 foundations, which is the equivalent to 2,800 m of conduit, using that equivalence we came up with in the previous section.

Okay, the next thing we need to do is we need to come up with our daily targets. How much work do we have to do per shift, per day? Or you could do this weekly or monthly, depending on the project. For example, pits, conduits, and foundations in zone A. We've got a design quantity of 7,350 m with 75 shifts, which come, we come up with a daily target of 98 m per day. We can do this for all the activities in our schedule. We come up with a planned daily target.

Then all we do to track progress is we set up an Excel template similar to this, where we've got for the activity, we've got our planned target each day, our planned total, so our cumulative total, our actual t, what we actually got each day, our cumulative actual, and then the quantity remaining. So, for example, on the 1st of October, we plan to do 100 m. Our cumulative total is 100 meters because we've only done one day of work, but we actually got 98 meters. The next day, we planned to do 100 meters. Our planned total is now 200 m because we should have done 2 days of work. Our actual quantity was 121 m. So, our cumulative total is 219 m. So, you can see that each day we track how much work we did versus how much we planned, which gives us the cumulative total and also a quantity remaining.

Okay, so if we want to track a milestone-driven task, now remember this is an activity which is a set of sub-activities with no consistent quantity or metric we can track. We need to determine the milestones that break down the task. We need to set up some sort of credit system and then we need to monitor against this credit system. Again, this isn't going to be as objective and scientific as a production-based task, but it's still a useful way of tracking activities that can't be represented as a single quantity of work.

So, for example, if we're talking about procurement, we might have the following milestones to represent a task. The tender package is ready and prepared by a team. The tender has been issued to the market. We've received quotes back. We've awarded a contract and then they've mobilized the site. So the activity of procuring a subcontractor is broken down into five different tasks. We then apply a percentage to each of these tasks that would, in best match the reality of how much effort or time that task would plan to take as a representation of the overall task. For example, the tender package being ready, we represent as 10% complete. The tender issued and sent out to subcontractors, we represent as 20% complete. The quotes received back from subcontractors, we say we're 50% complete on that task. The contract has then been awarded, signed, and negotiated. We say we're 75% complete. The subcontractor on site, mobilized, ready to begin works is the 100% complete milestone.

Basically, when we're setting up a credit system, we just want to come up with some realistic, logical weighting of tasks that represent the real level of effort or duration. It takes one week to prepare a tender, two weeks to get the quotes. The activity of getting the quotes should be worth two times the preparation of the tender. It's really simple. It's just how long that task we're planning for it to take, how much effort does it take, and just weighting the sub-activities appropriately. Then simply based on what step we're up to in the overall process, we can make a pretty accurate estimate of the overall task completion. Again, it's more subjective, less scientific than a production-based task, but it's the best way we have to do it. The better the metric we have, the better or more accurately we've broken down the tasks, the better the actual information in our project schedule is going to be.

Just to summarize, where are we up to in terms of tracking progress? We've understood the task. We understand if it's production-driven or milestone-driven. We've set up a progress tracker, a way of capturing the raw work performance data. And we're monitoring our task every day. We're recording how much work is getting done. We're comparing this to our planned targets.

So what we've tracked so far is our raw work performance data, simply how much work we're getting done. We can then calculate a series of metrics with this that help us to better understand how we're tracking. So the first one is percentage complete, which is simply the work we've completed divided by the total quantity of work we need to do. We can also calculate our production, which is the quantity we've completed divided by the time elapsed, which allows us to calculate a daily or weekly production what we're actually hitting. We can calculate our schedule variance. So, schedule variance is the difference between how much work we've done minus how much work we plan to do. If we get a positive schedule variance, it means we're ahead of schedule. We get a negative schedule variance, it means we're behind schedule.

Similarly, we can calculate our schedule performance index. So, schedule performance index is the ratio of earned value, how much work we've actually done divided by planned value, how much work we plan to get done. We can also calculate our estimated completion date. So, estimated completion date is elapsed time. So, how far we are in the task currently, plus the ratio of the work remaining divided by our actual production rate. So, basically, we've done, we're 5 days into the task. We've got 100 m left to do and we're doing 20 m a day. Then we're going to need another 5 days to finish. That gives us our estimated completion date.

Let's work through an example. Say we're installing inverters on a solar farm. We've got 100 inverters to install. Our plan is to hit four per day, which gives us an estimated duration of 25 days. As an example, we're at day 10 and so far we've installed 25 inverters. So at day 10 of the task, let's calculate all our key metrics. So, percentage complete. Well, we've done 25 inverters. We've got 100. So we're 25% complete. Our actual production, we've done 25 inverters over 10 days. So our actual production is 2 and a half inverters per day. Our schedule variance, well, we've done 25. We should have done 40, which after 10 days at four per day, that's our planned value if we'd planned to do four per day. So we're 15 inverters behind schedule. Our schedule performance index is the ratio of what we've done versus where we should be. So we're at 0.625, which means we're doing 62.5% of the work we should have been doing. And our estimated completion date is day 10, where we're up to now, our elapsed time, plus the ratio of the remaining work we have to do by our actual production rate. So we've got 75 inverters left and we're doing two and a half per day. It's going to give us 30, which means our forecast completion date is day 40.

As you can see by calculating these metrics, we've given context to our raw data. The next thing we need to understand is that this information is only useful if we act on it. So, it's great we've calculated these metrics, but what are we actually going to do about them? So, this leads us to the idea of a treatment. The only value information has if we act on it. If not, it's a waste of time. Same with planning without action, it's just a form of procrastination.

So, what do we do if the works are delayed? What do we do if we calculate our metrics and we see that we're behind schedule when we need to apply a treatment? Treatments is all about understanding what can we do about the delay and choosing the optimal solution to the problem. So when we're choosing a treatment, we need to understand first. So what type of activity is being delayed? We need to then identify the root cause of delay and explore options we have and correctly implement them.

Okay. So there's fundamentally two types of activities that can be delayed. A critical path activity, which is an activity that will delay project completion. And importantly, we also want to talk about near-critical path activity. So these would be activities that have less than 10 days float, or whatever a reasonable reference point is depending on the type of project you have. If it's a short project, it'll be plus or minus one or two days of float. If it's a really, really long project, it might be activities that have within 30 or 40 days of float. The idea here is your critical path is a calculation, and so it's never going to be 100% accurate. The other type of activity that can be delayed is a non-critical path task. These are activities that have a significant amount of float that we can delay without impacting the project finish date.

Then we need to understand the specific root cause of the delay. Is it a resource constraint? Can we not get enough people or machines to do the task? Is it planning or scheduling issues? Are we have we poorly planned? Is our initial plan wrong? Do we have project management issues? Is we're not managing or coordinating the works properly? So we have technical challenges. There's complex design or construction methodologies or design constraints that we need to address. Are there external factors or stakeholder approvers holding us up? Really need to dig deep to understand what actually is holding the activity back. What has changed from when we prepared our baseline schedule.

So, we've understood whether it's a critical or non-critical task that's being delayed, and we understand the root cause of the delay. What can we then do about this delay? Well, there's fundamentally two things we can do about a delay. We can optimize and improve, which is improving the systems and performance, how we're organizing the works, coming up with better design solutions, all these sorts of things. Or we can do both. Or we can add cost and risk to make sure it's done faster. This means crashing, where we add additional resources. We go from two crews to three crews, or we fast-track tasks. So originally, we might have planned to finish one task and then start the next one. Maybe we can start the following task with a 50% overlap.

Now, for optimizing and improving the task, we should do this for all activities. We should constantly be asking, how do we do a better, faster, cheaper with a better design? We should always be doing that. That would apply to both critical and non-critical tasks. But if we're talking about crashing or fast-tracking activity, adding cost and risk, we should only do that with critical path or near-critical path tasks. But at the end of the day, you're going to spend more money and add additional risk. And the only reason we would benefit from doing that is if it's a critical path task. If we can delay an activity and it doesn't impact the finish date, then we shouldn't be spending money or adding risk to do it faster. Should only be doing that for critical tasks.

The fundamental reason most schedules fail is because they're disconnected from the way projects are actually delivered. Here are 10 traps to avoid so your schedules reflect reality, and to get ahead of 90% of project schedulers. I'm going to break these 10 traps into four sections: planning mistakes, logic mistakes, communication issues, and monitoring and adaptation issues.

Planning mistakes are mistakes you make while you're setting up the initial schedule. And the first one is being precisely wrong rather than roughly correct. It's trying to build a highly detailed schedule in week one when you don't have any information about how the job will be built. It wastes tons of time on tasks that will change and it creates a false sense of precision that just is not based in reality. So when you're first creating your schedule, start high-level and then progressively add detail as you get better information. Start high-level. Get the job duration and overall methodology roughly correct and then add detail when it becomes available.

Mistake number two is blindly copying other projects. Every project is different. Every project is unique. Yes, templates can be recycled, but other projects should only be relied on with caution. I was working on a solar farm and I remember looking at the schedule and trying to understand why a specific activity was being rushed so aggressively and why it was coming up as holding up the entire schedule. And it was because we'd copied the template from another project that had a specific requirement in it for our development approval. We needed to put up the external fencing and landscaping, which wasn't applicable on the project we're working on. So, we could see that the landscaping was holding up the entire construction of the panel system. It made no sense until we realized that the planner had simply copied a template from another project. So yes, you can recycle templates, you can use other projects, but you need to fundamentally understand how the project's going to be built and the project specifics and constraints because if you're just copying other projects, they might have unique requirements that aren't reflected in our project.

The next mistake, which always confuses and overcomplicates things, is adding discretionary linkages too early in the planning process. This is when we're creating our first cut of the schedule during the planning phase and we add in a ton of non-contractual or preference-based linkages that don't match the hard logic of how the project has to be delivered. It extends the duration artificially. It adds confusion and it'll make optimizing the schedule much more challenging. So when you're first building your schedule, focus on the hard physical dependencies, the actual construction methodology, what you have to do to build the job. Then add in things like resourcing or other issues you want to capture in the schedule, preferences on how to build it, how to optimize for cost. Add this in as a later optimizing stage of building the schedule.

And the final planning mistake is not properly linking procurement and design. People focus way too much on construction. They get into the details, but to build anything, you need drawings and you need materials and subcontractors. So failing to properly capture the durations of these tasks, the dependencies of these tasks will lead to a schedule that is a very detailed construction phase, but everything that happens before it being completely wrong.

Okay, so those are the mistakes people make during the planning phase. What about logic and data issues? These are issues with how the schedule is fundamentally structured and set up to track progress during construction. So the biggest logic mistake I see is people ignoring the logic and the methodology of the project. The schedule has to reflect reality. It has to reflect how the project is actually going to be built. If for whatever reason an activity can't start before your client's not giving you access, that has to be in the schedule. That is the thing that's driving the start date to that task. The schedule has to reflect reality. So many times you look at a schedule and it just doesn't actually reflect the way the work is being done. So you always have to be asking yourself the question, is this what's actually holding up the task? Is this what the task is actually dependent on? Again, it's all about being critical of the schedule and ensuring that the plan reflects reality.

The next mistake I see people make is similar to the earlier one I had, which was about being precisely wrong rather than roughly correct, which is obsessing too much over the numbers rather than what they mean. People get way too fixated on percentages complete, dates, floats, the critical part without really understanding what they represent and the sequence of the overall project and how they all fit together. It's being again too precise rather than roughly correct. It gives you a false sense of control. For example, a task might be marked as 90% complete, but that final 10% complete of the task might be some sort of defect that has a 6-month lead time on the materials we need to fix it. If you looked at the schedule and you didn't understand how that 90% complete was made up of and that we were actually looking at a 6-month delay to rectifying a defect, we need to have closed out before practical completion, then you're completely missing the point. Fundamentally, you still need to have a firm grasp of how the job's actually being built, the methodology, how the data is being captured, and what it actually means. You have to understand the methodology.

The next mistakes I want to talk about are communication issues. These are mistakes that happen when planners and the construction teams are out of sync. The big one I see here is a disconnection between planners and construction. This happens when the schedules are created in isolation without input from the people managing and delivering the project. The sequence doesn't match the real-world site conditions and the team therefore don't look at the schedule. They don't use it as a planning tool and they don't see it as their plan. So they don't have ownership over the outcomes. Fix to this is really simple. If you're the planner, you need to involve the people doing the work. They understand it better than you and you want them to have ownership over it. Need to get them involved in the planning process. You need to work out a way to make it their schedule.

The next mistake I see is people focus on schedule development and schedule tracking, monitoring, and controlling, but they ignore the fundamental step of implementation. If you create a schedule and don't implement it, as I've said before, it's a waste of time. You need to work out a way to take the plan that exists on paper and turn it into a to-do list. Need to work out how to bridge the gap between scheduling as a project management tool and time management and to-do lists. You need to work out a way that people can take the schedule, turn it into a set of actions, and then follow up on these actions. This is where scheduling and time management and organization are highly interrelated.

And the final category of mistakes I see people making all the time is monitoring and adaptation. You need to adjust the plan when conditions change. A big mistake I see people making here is they treat the schedule as a Bible rather than a guide. Again, they follow the schedule blindly even when the conditions on site change. It becomes a tool that people use to blame when things go wrong rather than seeing it as a guide and understanding it might be incorrect. There might be issues with it, but you need to take ownership of it. Understand what mistakes are in the schedule. Understand the way the job actually has to be built because fundamentally you're there to meet the finished dates, not to follow the schedule. And finally, people fail to update and maintain and reforecast the schedule. They treat the schedule. They develop it as a set and forget strategy. They build the schedule. They save it on their desktop. They never look at it again. And then they go and make all the mistakes that they identified in the schedule as issues that were going to come up on the project. Again, you need to constantly be referring to, maintaining, and updating the schedule so it remains a useful tool to plan and coordinate the project.

Whether you like it or not, making money in construction is more than just building stuff. It's more than just building stuff on time and budget. Yes, obviously that plays a huge part, but to make money in construction, you need to build something and then get paid for it. That's where contracts come in. Unless you are a commercial person, most people I know in the construction industry hate contracts. Construction contracts contain hundreds of pages with multiple attachments. They all reference different parts of the documents, and we can all agree they're not written to be user-friendly. But as I'm going to show you in this course, contracts are actually unbelievably simple. You just need a framework to understand them, and to learn how to use them to your advantage.

In this course, I'm going to show you everything you need to know and understand about construction contracts and procurement so you can boost your margins, boost your cash flow, and reduce your risk. We're going to be covering why contracts matter and how they're used. What actually is a contract, the structure and contents of a contract, and then we'll jump into contract management, and go through the four domains of construction contract management. We're going to talk about both upstream contract management, downstream contract management across the formation and administration phases. So that's the four domains of contract management. We've got tendering, which is upstream contract formation. We've got procurement, which is downstream contract formation. Then we've got both head contract administration and subcontract administration. Each of these domains, we'll talk about the tools and techniques you can use to boost your margins, reduce your risk, and increase your cash flow.

So, let's start with the big important question. Why do contracts matter in construction? So, I want to answer this question by first setting the scene. So imagine we're building a new road, a road construction project, and I first want to understand what's involved in the process. Well, we need to start with feasibility and planning. We have to decide whether the road is worthwhile to build. We'll need a concept design. We'll need some cost estimates. We then go on to our design development and design approvals. We need detailed drawings and specifications that tell us exactly what to build. They have to comply with the feasibility approvals, our budget constraints, and also our development approvals. We then need to start with the bulk earthworks. We'll need to move soil, move a huge amount of cubic meters of dirt to make way for the road formation. We can then install underground utilities, electricity, lighting. Maybe we'll have to relocate some services like gas or telecommunications. We'll then need to actually construct the road formation, the asphalt paving, put in any sort of landscaping and roadside furniture. On top of that, we'll need a team of people planning, coordinating all these things, managing the impact to the community, managing all the separate traffic diversions.

Now, when we map out all these steps from the initial conception and feasibility to the end opening of the road, all the different construction activities, all the different approvals, design processes, all the different expertise that are needed, we can very quickly establish that no single company or public government department could complete all of these works in-house. It's just not feasible considering how many different sorts of expertise and skills needed to construct a road. There needs to be a way for separate companies to come together and all work towards this same objective of building a road.

Now, this comes the idea of an agreement. For any two companies to collaborate and work together, they need to have some sort of agreement. One party needs to agree to do something. The other party needs to agree to compensate for them. For example, say the project owner who's done the early stage design and feasibility studies for the road decides that they do, in fact, want to build this road. First thing they're going to do is they're going to go to a general contractor, a head contractor, and engage them to do this. They want a single person they can pay to deliver this project. So, the project owner will say, "I'll pay you $30 million." And the contractor is saying, "I'll build this bridge for you." They're making an agreement. One person's offering a service, the other person's offering to pay them for it.

A contract, therefore, is just a legal tool used to formalize this agreement. So, fundamentally, that's why contracts matter in construction because we need all these different parties to work together. We need them to form agreements, and the contract is the legal tool that formalizes this agreement. When we say they formalize it, it means it's legally binding, which fundamentally means the courts will enforce it. The contract defines who is responsible for what. This means what and how they're going to get paid, when will the work get done, what risks are they responsible for, how do changes to the scope of the project get managed, what happens if arguments or disputes arise, and any other relevant terms and conditions. The contract is the legal mechanism, the way we formalize this agreement.

Now, the attitude of a lot of people in the construction industry is that contracts are paperwork and once you sign the contract, it pretty much sits in a folder and never gets referenced for the entirety of the job. So, we've established why contracts need to exist. But then there's this other prevailing belief that I see time and time again in the construction industry is that people think contracts just get signed, they sit in a folder, then nothing ever happens with them. So now I want to talk about specifically for contractors why effective contract management isn't just a formal process that is used to capture an agreement. It's actually a tool at your disposal that you can use to boost your profit margins, reduce your risk, and improve your cash flow.

So I want to give you one really simple example from my own career why I know contracts don't just sit in folders. So I was working as a contractor on a major electrical construction project and the procurement of the package from our client was rushed. They really pushed us to sign the contract to get onto the site to start working because they had deadlines that they had to meet. We agreed to a whole lot of things with our client verbally or in meetings, and we had a shared understanding of how the scope was going to work. Things like we'd priced over a bill of quantities, and then the client agreed that the bill of quantities was a source of truth over the drawings, and if there was a change in the quantities, there'd be a change to the contract price. None of this stuff was documented to an extent in the scope, but it wasn't clearly spelled out in the scope. What happened about a month into the project? The client changed their project manager. And so all these issues we were having with the quantities being wrong, not matching the drawings, we thought we were entitled for additional money for because it wasn't written in the contract. The new project manager disputed everything. So it's an example where we thought we were relying on a relationship, but we soon realized that if it wasn't documented in the contract, pretty much everything was at our own risk.

So using the principle of inversion, let's ask ourselves a question. What happens if you don't manage your contract? Well, you do work you don't need to, and you don't get paid for it. So you're incurring costs and not getting a corresponding increase in revenue. A delay happens, but you don't notify your client in time and you wear the cost of this delay and potentially incur liquidated damages at the tail end of the contract because you're late in finishing. Your subcontractor underperforms and you can't have any way to recover the cost of their poor performance. Your client stops paying you, and you have no idea what to do. So these are all situations that can happen if you don't manage the contract effectively.

So there's two sides of construction management. There's the side that most construction people intuitively focus on and are in the part they like, the part they're good at, which is doing a good job delivering the work on time and on budget to the standards in the specifications. Building the correct thing and building it under budget and ahead of schedule. We all know we need to do this. Then there comes the contract side of things, which is doing the work, but also getting paid for it. We need to manage the works, but we also need to manage the contract to have a successful project outcome.

So, I have some stats to back up the claim on making the contracts matter. There's a couple of big studies that have showed that improving contract management drastically improves your project performance. McKinsey in 2017 found that poor contract management is responsible for a loss of 5 to 15% in project value. Considering the average margins people operate on are like 10 to 15%, that's a huge amount of money. The World Commerce and Contracting Association found that ineffective contract management leads to an average revenue leakage of 9.2% per project. Again, very similar statistic, very similar result. You can basically wipe out your profit margin by not managing a contract properly. And a KPMG construction survey found that only 31% of contractors say they consistently deliver projects on budget. Contract controls are a key reason why. One of the key reasons I listed was not having effective contract management.

Okay. So when I talk about why contract management matters, I always break it down into these three buckets. We've got profit, which is getting a higher revenue than your cost base. We've got risk, that is preventing the preventing bad things from happening. And then we've got cash flow, getting paid before you incur cost. Contract management helps you to do all of these things.

So increasing your profit. Contract management helps you make claims and then get paid for variations and scope changes. So if you do more work, you get paid for more work. It avoids doing unapproved or unnecessary work. So not incurring costs that you shouldn't have. Helps you to justify any extension of times and recover any delay-related costs. So if you're delayed in doing the work, you'll get a corresponding increase in your contract value if you manage the contract effectively. And it helps you to capture any back charges, day works, and entitlements to your subcontractors. So if your subcontractors have underperformed, it helps you avoid paying them additional money or incurring additional costs.

Contract management also helps you to lower risk. So to lower the uncertainty that matters to the project. This is by clarifying who is responsible for what and when. It helps to protect against liability creep and unfair instructions from your client. Helps you to avoid liquidated damages. So risks associated with finishing a project late. Helps you to effectively transfer risks you're responsible for in the head contract to your subcontractors. And it helps you to comply with legislation. Result is fewer surprises, stronger protection, and more control of your obligations.

And finally, it helps you to improve your cash position. As contractors know, cash isn't always an issue on construction projects. So contract management actually helps you to improve your cash flow. Helps you to negotiate favorable contract terms, favorable payment terms in contract formation. Helps you to ensure that you make your payment claims on time and you get paid for the work you've done. Helps you to use notice procedures to trigger payment claim variations and delays. And it helps you to track and follow up on unpaid invoices using only contract mechanisms. The result is to get money in your bank before you incur costs.

So, I know we've already briefly touched on what a contract is, but in this section, I want to dive a little deeper into specifically what is a contract. We know it's a legally enforceable agreement, but let's break that down. Let's look at the specific characteristics that have to be in place for a contract to exist. So a contract, in terms of legal speak, terms of what the courts refer to it as, it's a legally binding agreement between two parties, and it creates enforceable rights and obligations. So the terms and conditions in a contract, what we're signing up to do and what we're signing up to receive, become enforceable by the courts. Contracts are governed by common law principles. This means judgments by the courts around how contracts will be enforced and interpreted are governed by historic cases. And then based on this, the courts can either award damages or enforce penalties if you go to court.

Okay. So the legal foundations of what a contract are means to be legally enforceable. A contract has to meet certain criteria. There needs to be an offer. There needs to be acceptance. There needs to be consideration. So something of value moving between parties. There needs to be an intention to create legal relations. There needs to be a capacity to contract. And there needs to be certainty of the terms. So I'll break down what all these mean so you understand exactly what's involved for a contract to be in place between two parties.

Okay. So the first foundation of a contract is the offer. One party must make a clear proposal to enter into a contract. So, in construction, this would typically happen during a tender submission where a client provides a scope of works and a contractor provides a quote and methodology to deliver this work. Offer must be definite and intended to be accepted. For example, contractor says, "We will construct the pavement works for $1.2 million as per the attached scope of works drawing." So that's an offer. That is the first basis of a contract.

The next part is acceptance. So the offer creates is the first step. Then that offer must be accepted by the client. So the other party agrees to the terms of the offer without change. So the client comes back and says, "No, we want your price to increase reduce by $300,000." Then obviously, that is a counter-offer and needs to be accepted by the other party. They just can't automatically unilaterally deduct the price. Must be clear, unconditional, and communicated. And if the response includes changes, it becomes a counter-offer, not acceptance of the offer. For example, if with the pavement example, the client then says, "We accept your tender for the pavement works in full."

Now, for a contract to exist, there must be consideration, which means something of value must move between the two parties. So, in construction, this is work in exchange for payment. Without consideration, the contract is not enforceable, except in deeds, but they're separate. So, the contractor is offered to build the pavement for $1.2 million. The client is then agreeing to pay them $1.2 million. So, there's mutual consideration in that example. There's services from the contractor to the client, and there's the payment from the client to the contractor.

Now, for a contract to exist, there also needs to be intention to create legal relations. Both parties must clearly intend to enter into a legally binding agreement in commercial and business negotiations. This is presumed by default. For example, if someone sent you a scope of works with a draft form of contract, drawings, specifications, and you're saying you're willing to do it for $1.2 million, there's clear intention to create a legal arrangement. If you offer to mow your brother's lawn for $20, then there's no intention to create a contract. Just dealing between friends. So intention to create legal relations is another fundamental thing that has to exist for a contract to exist.

There must also be capacity to contract. So both parties must have the legal capacity to enter into a contract. This means they're of legal age and sound mind and have the authority to sign, which will be the biggest one you see in construction companies. For example, a junior graduate engineer on a project isn't going to be able to sign off on a $20 million project, and they would clearly not have the capacity to contract that. So even if they did sign it, it probably wouldn't count for anything because clearly that person would not have the authority. So it would not be enforceable.

There must also be certainty of terms. So the contract must be clear enough for a court to interpret and enforce. Vague or ambiguous clauses can make a contract unenforceable or open to dispute. Good contracts will clearly define scope, time, payments, and obligations. And if things are not defined clearly, the courts may not enforce them.

Next, I want to move on to talking about some core concepts of construction contract management. So, I want to start by talking about the two key roles in any construction contract. We've got the buyer and we've got the seller. The buyer is also referred to as the principal. They're the one acquiring the goods and services. They're paying for something to be done. So, for example, of a road construction project, the buyer is the state government, the project developer. They are the ones that want a road to be built, and they're the ones who are going to be paying for it. Seller is also referred to as the contractor. They're the ones providing the goods and services, and they're the ones receiving the payment. So in the example, the road project, they're the general contractor who's going to get paid $30 million to build the bridge. So they're going to be the ones organizing all the labor, plant, materials, subcontractors to do that, and they'll complete the works and receive payment from the buyer.

So breaking down these roles and some of the other roles that we typically see in construction contracts. So the principal is the client and the owner. They're the party who commissions the work, pays for it, they set the project objectives, they provide access to the works, and they review any claims to the contractor. The contractor, referred to as the head contractor or general contractor specifically, is the one managing the overall project, and they deliver the work as per the contract. They manage the program, typically the cost, subcontractors, and their obligations. Some instances you have a superintendent or a contract administrator. So this is an agent employed by the principal to manage the contract, but they're meant to be impartial and assess any claims from the contractor. You then also have subcontractors. So these are specialist contractors engaged by the contractor to complete specific portions of the project scope. For example, on the road project, the general contractor may engage an electrical subcontractor to complete the street lighting. Then the last party that we have on construction projects is the architect or engineer. They're the professional services provider who prepared the drawings and specifications and the detailed design. Depending on the contract model, they may be working for the contractor or they may be working for the principal.

So this leads into the contract model, which is the structure that governs the relationship between all of these different parties. You might have a design and construct contract, a construct only contract, an ECI or early contractor involvement, APC. There's tons of different models that are suited to different projects. And in the early stage feasibility stage, the principal needs to decide on the best structure for all these parties to work together depending on the specifics of the project. We're going to go through all of these models, but to start with, here's an example of a design and construct contract so you can understand what I'm referring to when I'm talking about the contract model. You have a project owner, the one who's deciding what to build and financing it. They're paying a general contractor to deliver the project or a head contractor to deliver the project. The head contractor is providing them the service, a building, whatever they're doing. Under a design and construct model, the head contractor engages the designer for the detailed design and engineering and also engages all of the subcontractors. So the project owner has no commercial relationship with subcontractors or the designer. They engage directly the head contractor. The head contractor then engages the architect, the engineer, and the subcontractors. In the same way that the project owner is the buyer and the contractor is the seller, in the head contract arrangement, in the subcontract arrangements, the head contractor becomes the buyer, the subcontractor and the designer become the seller. So they're the ones providing the services, and the head contractor will pay them for it.

When we talk about construction contracts and the relationships between all these different parties, an important concept to understand is the flow-down effect. So the flow-down effect is basically how requirements move from the principal to the head contractor to subcontractors. The principal originally specifies what they want. They want a bridge that meets these certain requirements. They want it built within 6 months. They have 20-day payment terms, all these different things. They pass these requirements on to the head contractor. The head contractor will typically pass these on to subcontractors. For example, the design drawings might say a 150 mm thick concrete slab in accordance with blah blah blah blah blah. There's a 24-month defect liability period. What good contractors do is they take the requirements from the head contractor and they pass these on to their subcontractors. They transfer responsibility and risk through this process.

Now, there's two core stages of contract management. There's the formation stage, the process through which a contract is created between two parties. And there's the administration stage. The administration stage is the process of monitoring and facilitating the smooth performance of the works. We form a contract. We agree to terms and conditions. Then we deliver the works in accordance with these terms and conditions.

Now, we can break this process down into four steps. We've got upstream and downstream contract management. So if we're the head contractor, our upstream contract is with the principal. Our downstream contract is with our subcontractors. And then there's two stages to this process. There's contract formation where we negotiate and sign a contract. There's contract administration. So forming the contract with our client. Upstream contract formation we refer to as tendering or quoting. Tendering, quoting, or bidding, whatever the specific term you use. Then there's procurement, which is downstream contract formation, which is finding subcontractors and suppliers to deliver the works on our behalf. Then once we sign a contract, we move into contract administration. We've got upstream contract administration, managing the contract with our client. And we also have subcontractor administration, managing the contract with our subcontractors. Again, so upstream contract formation or tendering is where we negotiate and sign a contract with our client. This means we need to review the project requirements, submit a quote and conditions of offer that align with the project, negotiate and sign a contract. The goal here is to win a project at a price and terms that we can then ensure we deliver profitably. We always want to be focusing on the terms and conditions of the contract, not just the price we sign up to.

Then we've got downstream contract formation or procurement, where we need to identify the packages we need to procure from the market, prepare and issue RFQ documents, review and negotiate contracts with our suppliers. The goal here is to find the best possible suppliers and subcontractors at the best possible price. We want to align scope, schedule, and risk responsibilities and transfer these obligations to our subcontractors so we're not caught between the requirements in the head contracts and the requirements in the subcontracts.

Then we've got our upstream and downstream contract administration. So upstream, the focus is getting paid for the work we do and fulfilling our contract obligations. So complying with all the rules the contract specifies to follow. Downstream contract administration is about providing access on time to our subcontractors so they can complete the works. If we're free issuing materials, getting them the materials on time, managing them closely. At the end of the day, we're accountable for the work we do. The worst thing we can do is let and forget and maintaining an alignment with the head contract. We want to get paid for the work we've done. We want to ensure safety, quality, and performance of subcontractors and we want to manage risk.

So now we understand the core concepts around contract management. We understand all the different parties, the relationship between these parties defined in the contract model, and also the different stages of the four stages of contract management. Let's now talk about the structure and contents of a construction contract. So head to the section by giving you a framework of how to think about contracts because the vast majority of people drastically overcomplicate them. You need to think about a contract as a rule book. They tell you what to do and when. They tell you what work you need to do, exactly what work you need to do, how to get paid for the work you've completed, what to do when things change, what you have to do to finish and sign off the contract, and so on and so forth. They're basically just rule books for the game you're playing. You can think of them as like the rules of a game of chess. If you think about contracts like that, they're going to become way simpler.

So, let me give you some examples of how you can think of contracts as rule books. Say, for example, you're the contractor managing a project and the materials you plan to order are going to arrive late. Does that matter? Is that important? Well, if you look at what the contract says, the contract says, so these are clauses from a real contract. Progress. The contractor shall ensure that the work under the contract reaches practical completion by the date for practical completion. So what that tells you is you need to finish the work by the date for the contract. If the contractor does not achieve practical completion by this date, they will have to pay liquidated damages. So you will get a fine for not completing the project on time. What does that mean? If your materials are going to come late and they're going to delay completion of the project, it means you're going to

To get penalized for doing it. So you have to come up with some sort of solution to this problem. It is a problem that does in fact matter. Let me give you another example. Say you're managing a subcontractor and they have a whole lot of defects and issues with the work they've completed and you keep telling them you have to come back to site and fix your defects. You have to come to back to site fix your defects but they're ignoring you and they're not doing it. What can you do about this?

Will refer to the contract, the section where it says defected work. It says if the contractor has failed to come back to site and fix their defects and you've provided them written notice, given the set period of time you've got to allow them to come back and fix their defects, if they haven't come back and fix their defects, referring to this clause in the contract, you are allowed to take out money from their security or money you owe them to go and rectify the defective work. So the contract is giving you a specific process to follow in this exact situation. That's what I mean when I talk about contracts as rule books. You think about contract management as a game. The contract is the rules for how to play. Your subcontractor is failing to fix their defects. There's a process in the contract you can follow to rectify this. Okay.

So now we understand this framework of how to think about contracts. They're just a set of rules. Let's talk about the structure of a contract. So contracts are typically broken down into three sections. We've got the general conditions of contracts. So these are standard terms used across many projects. In Australia, we have the AS4000 series. But in Europe, the UK, America, there's the FID and NEC contracts. They cover general rights and responsibilities such as payment, time, variations. The extracts I had in the last two slides, they were from general conditions of contracts. We've then got special conditions. For example, project-specific amendments to the general conditions. So these general conditions might be adjusted, and these override or modify the standard rules and often contain bigger risks. Then we've got attachments and supporting documentations. For example, to the general condition of contract, you might attach a scope of works, technical specifications, drawings, a bill of quantities, and so on.

Now I'm going to touch on some core concepts around the contract and the specific terms and conditions you need to understand. First one, which is always the most important one, is the scope of works, which defines the work you need to do. Scope is what you're contracted to complete. It typically contains deliverables, so what you're required to build, boundaries, where the work stops, where your interfaces are, any exclusions, what's specifically not included in your scope of works, and any interfaces or dependencies you'll have on other contractors or the clients. Scope is always an issue on construction projects, and it's always the biggest source of disputes. Why is this? Well, because construction projects are often technically complicated and difficult to understand. There's a lot of different tasks involved. There's a lot of different steps, and the scope is open to misinterpretation. There's always misalignments and misinterpretations. Fundamentally, what drives the cost of the project? The cost is the work you need to complete. There's always going to be disputes around scope because if you do less work, you save money. The principal has contracted work and they've got you to do it. They don't have to pay extra for another contractor to complete the work. So scope is probably where the biggest disputes around cost are going to be, and there's always documents that conflict each other. The drawings might say one thing, the specifications might say another, and the bill of quantities might suggest something else. So you need to understand the order of precedence, what order these documents need to be read and understood in.

So what are the tools we use in contract management to manage scope? There might be things like scope checklists. We use a work breakdown structure. We might have scope briefings with subcontractors. Fundamentally though, what we want to do is, if we're the head contractor, we want to take the requirements in the head contractor and make our subcontractors responsible for these same portions of the work. So it's always back-to-back with our subcontractors. This is fundamentally going to help us avoid scope creep and undocumented changes. So, basically, where we do additional work and don't get paid for it.

The next fundamental concept is time, when we need to have completed the work by. So these are things like the key dates, like the date we meant to start the work, any specific milestones we need to meet, when we need to complete the work, the defect liability period, whether there's any sectional completions. But also, we might have specific responsibilities to maintain a program. We might have to issue an updated program every two weeks or every month. In addition to this, contracts typically have liquidated damages. So, liquidated damages are a penalty that's enforced if we're late in completing the works. They might be $1,000 a day, they might be $10,000 a day, they might be a million dollars a day, depending on the size of the project. But basically, as the scope defines what we need to do, time defines when we need to do it, and because time matters so much in construction, we'll get penalized if we're late.

The construction program is how we communicate the progress of the project to our client and to our subcontractors. It will show the critical path, series of activities that if delayed, delay project completion, float, and any access dates to the site. So we need access to site on this date to complete our work. This is the critical path. This is the series of tasks that if delayed will delay our finish date, and any activities that aren't on the critical path will have some float associated with them. The contract program is the basis of any claims we can make. If our client is late in giving us access to the site, we can claim for delays. If a client disrupts a non-critical path activity but changes the way we're working but doesn't impact our finish date, we can prove and justify claiming costs for disruption.

A core concept around time, and a topic most people love, but it's a term people throw around without fully understanding what it means, are extension of time claims. Extension of time claims is when we adjust the finish date in the contract. To do this, we need to maintain a construction program. So we need to have a program that shows a sequence of tasks, the order they need to be completed in, and what date we need access from our client. To claim an extension of time, we need to demonstrate that a critical path activity has been delayed. For example, if we're doing a construction project and the date in our program that we need the IFC, or the issue for construction design, is the 15th of February. If that date elapses and we don't have the IFC design, we can claim a critical path activity has been delayed. So we need to adjust the finish date in the contract. When we're claiming, we can claim just time, which is adjusting the completion date of the contract, or we can also claim cost. For example, because the finish date in the contract is pushed out, we're going to need our project manager and site staff on site for another month, which is going to cost an extra $20,000 or whatever it is. So that's why you can see that time is such an important concept of any project because it has such an impact on both risk through liquidated damages, but also cost.

The next core concept in contracts is payment. How and when do we receive payment for the works completed, or how and when do we have to pay our subcontractors for the works they've completed? Payment, when it's defined in the contract, will include the payment mechanism, whether it's lump sum, schedule of rates, or cost reimbursable. The pricing schedule, so how our clients or how our subcontractors will bill us. The claim cycle, whether it's monthly or we get paid based on milestones. Any security we have to give, so whether we have to give, whether the client will hold retention or they'll hold a bank guarantee. Again, when I spoke about why contract management matters so much, it's because cash is key in construction. Construction operates on thin margins, and if you get delayed in getting paid, you can very quickly be cash negative on a project. Managing a contract is how we manage our cash cycle.

Okay, so what are the different payment mechanisms in the contract? We've got fixed cost. This is where there's a fixed fee paid to the contractor for the delivery of a fixed scope of works. We've got schedule of rates. So this is where there's a fixed amount paid per unit of work completed. For example, a contractor might get paid $128 per linear meter of subsurface drain. If they do a thousand meters, they'll get paid $128,000. They do 2,000, they'll get paid whatever double that is. I can't do the maths that fast in my head. Cost reimbursible is where there's payment to the contractor for the actual works completed plus an agreed-upon margin. So in this situation, the contractor has to provide evidence of the actual costs incurred. Or, finally, less common on subcontracts but common on bigger projects now, is a target cost contract where the project costs are agreed between the client and the contractor, and then they share any overruns between the parties.

Now, as a contractor, you need to be able to effectively make payment claims. That's the process through which the principal pays the contractor. So, how does this process happen? Well, each month or on a regular cycle throughout the project, the contractor will submit a payment claim to the client. They'll provide evidence of the work they've completed and what items in the payment schedule they're claiming against. What happens then is that the principal will then review this payment claim. Maybe the contractor is claiming to say they've done 1,000 meters of drainage, but the principal thinks they've only done 950 meters. They will negotiate this and agree on the value of the claim, then issue an invoice or a payment certificate. Once project completion, once the contractor has completed the work, they'll submit a final payment claim, which will start the defects liability period. And at the completion of the defects liability period, the principal will return the contractor's security and they'll finish the contract.

Okay, so how are payment claims typically structured? Well, you typically structure your payment claim in an Excel workbook, and each month the contractor makes a payment claim to the principal. For example, for street lighting civil works, we've got here there's a rate in the contract for each of the different types of trenches, which probably correspond to different widths and depths, a rate for light pole foundations, a rate for pit installations, a rate for distribution board foundations. There's a quantity and a rate against each of these. And each month, the contractor submits a claim to the principal that says, "I've done 193 meters of trench type A at unit rate $1,200 per meter, or sorry, $400 per meter. This equates to a claim of $200,000 or whatever it is." The principal then assesses this. They then say, "Nope, you've only done 200 meters. We value this claim at X and negotiate this." They agree on a claim value, and that becomes the claim. The contractor submits the principal.

Okay, partly tied into payment, and I mentioned it briefly when I spoke about retention and bank guarantees, but we also need to understand security. Security is fundamental to any construction contract, and it's basically financial guarantees that one party gives the other. Typically, the contractor gives it to the principal, and it can come in the form of retention, where the client holds a portion of every payment claim; bank guarantee, where the contractor gives a sheet of paper to the principal saying there's a million dollars in this bank account, and if I fail to complete the works, you can take this to the bank and take the money; or the third form of security, which isn't written into the contract but works the same, is the value of the work completed by the contractor that they have not been paid for. So the contract specifies the form of security the principal will hold, the amount of security, the timing when it will be returned, at practical completion and at the end of the defect liability period, and the process the principal can use to draw down the security. So if they're going to take money off the contractor from their security, what is the process they need to follow?

So the principal can access this security, and this is what most contracts say: whenever the contractor is in default and failing to complete the work under the contract. This means any additional costs incurred by the principal can be recovered from the security. For example, the contractor is failing to rectify their defects. The principal's given them notice, asked them to come back and fix their defects, and they're refusing. The principal can then access this security. They can take this money and use it to pay another contractor to come back and fix their defect. If the contractor has left the site dangerous, maybe they left a huge open excavation in the road, they're not coming back to fix it, the principal can access the security to get them to fix it. Or, basically, whenever there's a reason, the principal can take work off the contractor and engage another contractor to rectify any shortfall.

Insurance and risk are another core concept in any construction contract, and it's this idea of who covers what when things go wrong. So insurance, as you know, is the same as you get home or car insurance. Construction contracts also nominate requirements for contractors to hold insurance. So insurance provides compensation for a specified loss and is a risk management tool. It's mandated in construction contracts to protect the principal or third party if a risk plays out and the contractor is unable to cover the cost. The types needed depend on the work being completed by the contractor. The contract nominates the type of insurance the contractor needs to hold and the level of cover, whether it's $20 million or whatever.

Okay, so the main types of insurance you see in construction contracts are contractor's all risk insurance, which covers loss or damage to the works for the project duration and is taken out by the head contractor. Public liability insurance, which covers damage to people and property outside of the work and is required for all parties involved in a construction contract. Workers compensation insurance, which covers the costs associated with injuries and rehabilitation to construction workers. This is generally mandated by law. And then we've got professional indemnity insurance, which is when you're providing any sort of professional service or technical expertise, which covers any breach in duty. So if you're a civil engineer designing a foundation, you design a foundation the wrong depth, you're covered by professional indemnity insurance. Now, depending on the project specifics, other types of insurance may be required. For example, if you're buying expensive plant overseas and you're shipping it, the contract may say that you need maritime transit insurance.

Now the next topic, the one everyone loves, variations. How do we manage change of the contract sum? When we were talking about payment mechanisms and we spoke about fixed fee contracts, we said the contractor is paid a fixed fee for completing a scope of works in accordance with the contract. Variations are how we manage changed scope, time, quality, project requirements, and how the corresponding fixed fee is adjusted. So basically, the principal changes the requirements, then the fixed fee needs to be adjusted to reflect this, and that is managed through variations. There are two core types of variations. There are variations instructed or requested by the principal, and there are variations claimed by the contractor.

So a variation proposed is when the principal acknowledges before the fact that there's been a change. For example, they're building a building and the principal says, "Oh no, I actually want this new architectural feature outside the building, which was never in the scope to begin with." The process for a variation proposed is that the principal proposes the additional scope to the contractor. The key here again is that it's agreed before the proposal. Everyone agrees there's a change to the project scope. The contractor will then review this requirement and then advise on the feasibility of it and the cost or schedule impacts to the project. For example, they say, "To add this new architectural feature, it's going to take us a month longer to finish the project and it's going to cost $100,000." The principal will then review and assess this, and they'll negotiate it to determine whether they agree to this cost impact or whether they actually want to proceed with the change. They then decide whether to proceed with it as either an approved variation or they decline it. If they decline it, there's no change to project scope. If they approve it, then there's an adjustment by the time and cost agreed to in the variation.

Now, on the other hand, we've got variations claimed. So these are everyone's least favorite topic. It's where all the arguments occur on projects, and it's where the contractor believes something has changed and they present this to the principal and say, "Hey, you've delayed us by accessing site by one month. Because of this, we need an extra month to finish the project, and you need to pay for our indirect costs for another month, which is going to be $100,000." They become aware of the grounds for a claim. So the key here, which is different to a variation proposed, is with a variation proposed, everybody agrees there's been a change to the scope. With a variation claimed, there is no implied agreement that there's been a change. So which means the principal will argue one, that the change exists in the first place, and then two, the cost impact of the change. So in this situation, the contractor becomes aware of the grounds for a claim. "Hey, you've delayed us accessing the site." They'll present this justification. They'll submit a notice of the claim and details of the claim.

Now, contracts have in them time bars. A time bar just means that once you become aware of a change, you might only have 48 hours within which you have to notify your client. If you're late in notifying them of the change, you may not actually be entitled to claim for the change. So you have to submit any notices within a time bar. The claim is then assessed by the principal superintendent. You might have extra time to prepare your cost estimate. How they assess the claim will be the cause. So who has actually caused it? Obviously, if the contractor is late in ordering materials, they can't bill the principal for that. There's no grounds for a claim. But if the principal, or they're both at fault, then there will be grounds for a claim. They will assess the impact of the claim. So they will have agreed the claim exists. Then they assess the cost and time impact. They negotiate it. They review the impact on the schedule. Has a critical path activity been delayed? And then they determine what compensation or change to the contract there is.

Now, once we talk about variations and claims, it only makes sense to then talk about disputes, because all disputes start with arguments over variations and scope. In the contract are specific mechanisms for how to resolve disputes. What happens when things go wrong? What happens when the principal and the contractor aren't getting along? Typically, what causes disputes are payment issues, delays to payment, arguing over payment claims, variation disagreements, and EOT disagreements. The contract will have specific resolution mechanisms within it. So the contract might specify that first you have to have a site meeting, then it has to be escalated to senior representatives from the company, then you have to go to mediation, and then if none of that can be resolved, you go to arbitration in courts. In Australia, because payment is such a big issue, and in most countries where contractors use it as a bullying tactic for subcontractors, there are very strict laws around payment in the Security of Payment Act. To manage disputes effectively, you need really good records, site diaries, records, drawings, exactly what's happened and why it's happened. And at all costs, you should avoid escalation. It's always better to manage things as a project team at the site level rather than going to senior management.

And finally, last but not least, we've got termination. How the contract can be ended. The contract within it will specify when and how the contract can be terminated. So for cause, when there's a serious breach by one party for another, for example, if the principal has stopped paying the contractor or the contractor has walked off site and is not doing the work. You can, some contracts will have it so the principal can terminate the contract for convenience, or there can be mutual termination. Both parties agree not to do the work. The procedure around termination will pretty much be there'll be some sort of notice period. The contractor will have to make the site safe and demobilize, and there'll need to be financial settlements. So the contractor will need to get paid for the work they've completed. And there's also risk protection. So termination clauses when the principal can terminate the contract, or if the subcontractor or contractor goes insolvent, how to manage the insolvency process.

Next, let's talk about the different types of construction contracts. In the previous section, we spoke about all the different parties involved in delivering a project. The project model or the contract type specifies how all these different parties are going to work together, and the project owner needs to choose the optimal contract model to best suit the type of project and their objectives. So, talking about the contract model, we're really talking about answering a couple of key questions. Things like who does what? Who's responsible for the design? Who's responsible for the construction? How is payment structured? Is it going to be cost reimbursable, or is it going to be a lump sum? Who bears the different risks for the project delivery? The cost risk, the time risk, risk for design errors. And then also, how is the project model going to be used? So all these questions need to be answered to come up with the optimal contract model.

So the first most common construction model we see is the construct-only model. So the construct-only model is where the client completes the design themselves. So the project owner directly engages the engineer or architect to complete the detailed design. All the contractor is doing is getting given this IFC set of drawings and building to the drawings. It is also referred to as traditional procurement. The contractor quotes off the design to build the design. The contractor builds the design, and any issues with the design become a variation to the contract. If there's an error or an omission in the design, the contractor will get paid for the rework associated with that. Payment is fixed and lump sum. The contractor bears all the risk for the construction cost but does not bear any of the design risk. So these are used in traditional projects, and you need to have a client or a project owner who knows what they're doing. They need to be able to manage the design themselves, pick up constructability issues, pick up value engineering opportunities. So it's typically done on more traditional building projects.

Design and construct is where the contractor is engaged for both the detailed design and the construction of the project. So the client prepares an initial concept design and specification. The contractor quotes to complete the detailed design and construction. So they base it off this concept design and the specifications. They'll need to take the design to IFC and then build in accordance with this design. The client selects their preferred contractor, which is going to be a combination of their price to deliver the works but also the technical solution they're proposing. So when the contractor is tendering for the works, typically they'll complete a 15% or tender design revision, which the client will review, and they'll make the decision based off both the design and the construction solution. The contractor then manages the architect and the engineer to take the design to IFC and then they construct this IFC design. Again, payment is fixed lump sum. The contractor is bearing all the risk. The contractor in this contract model is also bearing the design risk. So any issues with the detailed design, IFC drawings, any omissions, any lost opportunities, the contractor is bearing that risk. The only exception to this would be when the principal is requesting a change to the initial specifications or concept design. This model is best used when you want a single point of accountability in the contractor. However, the project owner does not have the expertise to manage the design themselves. So they want the contractor to identify the value engineering opportunities and factor this into their pricing.

Now, construct-only and design and construct, they're both lump sum contracts. The contractor is paid a fixed fee for delivering the work. A cost plus contract is a cost reimbursable contract where the contractor is paid for the actual cost of doing the work plus a fee. So the client chooses a contractor based on their experience or capability. The design is done by the client. It's given to the contractor, and they deliver the project as per the client's directions. The contractor is paid the actual cost of the works plus a fixed fee or percentage markup. It might be 7%, it might be 15%, depending on the contract type. In this situation, the client is bearing all the financial risk, and because of this, the contractor has less of an incentive to be efficient and cost-effective. These types of cost plus contracts are used when for time-critical work or what scope is hard to define or messy. So, for example, if you're doing a brownfield upgrade to rail infrastructure where it's not clear what's already installed, what has to be replaced, this would be an example of a cost plus contract.

A target cost contract is similar to a cost plus. However, the contractor and the client agree to a budget for the project, and they share underruns and overruns. So in this situation, the contractor isn't bearing all of the cost risk like a construct-only or a design and construct contract, but they're agreeing to a maximum cost, and then they're going to share any overruns or underruns. So the contractor is incentivized to be more efficient with their spending. Then the contractor delivers the project. The payment for the contractor will be the actual cost of doing the work plus their markup plus their pain or gain share. This is used on complex high-risk projects where you can't find it. Typically, a project owner would want to engage a contractor under a construct-only contract, but a lot of contractors might not accept that. There might be huge risks, or there might be situations where the contractor will almost certainly be able to claim for variations or additional scope. Using a target cost contract, you don't have that same adversarial relationship when change happens with construct-only and design and construct contracts.

Now, the final contract model we'll talk about is a construction management agreement. This is where the client hires the contractor to manage the project on their behalf. So the contractor is engaged almost as a professional service provider, in the same way as a design engineer or an architect is engaged. So the client would select the contractor based on their experience and their capability to manage the project. The contractor would manage the trades, the engineers, the architects, the third parties. They basically manage the project on behalf of the client, as opposed to doing it under a fixed fee. So, in terms of how payments worked, the contractor would quote to deliver the construction management services. So they're paid a fixed fee for the services they provide, but the subcontractors are all engaged directly by the project owner. The project owner is paying the actual cost of delivering the project. In this situation, the client is bearing all of the financial risk, all of the errors with any issues with the design, any issues with construction works on site. The client is bearing all of those. The contractor is purely acting as a coordinator. These construction management projects are typically used for fast-tracked or complex projects, but they're also used for mega projects. Say there's some $40 billion oil and gas facility upgrade where the project is just too big of a financial risk for a contractor to take on as a design and constructor as an EPC. It's very typical that the project owner still needs the expertise of a competent contractor. So they'll engage them under a construction management agreement, and they'll help to manage large subcontractors.

So that was a really brief, simple overview of some of the typical contract models we see. Now we're going to talk, move on to talking about contract management. So so far, we've spoken about the different types of contracts, what contracts are, the different parties involved in a contract. Now it's time to talk about how to actually manage contracts to boost your profit, reduce your risk, and optimize your cash flow. So, had we introduced the idea of contracts, we used the analogy of the rules of a game. Contracts aren't just a legal document. It's a rule book for how the project should be delivered. It tells you what to do in different situations. But knowing the rules isn't enough. You need to be able to play the game, which is where contract management comes in. Contracts are the rules. Contract management is how you play the game. It's about understanding your obligations, managing risk, securing your entitlements, and navigating challenges that come up throughout the project, all by playing by the rules, but knowing how to play to win.

So, what is the goal of effective contract management? Well, the first one is to get paid for the work you do, but also to get what you paid for with your subcontractors and suppliers. It's about minimizing disputes as they come up, handling delays, claims, and risks to ensure you get your entitlements and you're getting your obligations, but also ensuring that you're not exposed to unnecessary liabilities. So, there are two stages to contract management. There's contract formation and contract administration. Contract formation is the stage when we set up and negotiate the agreement. We set up an agreement with our client that ensures we've got reasonable terms and conditions and the opportunity to make money on the project, and we negotiate agreements with our subcontractors to ensure we're getting the best value for money from the market. Contract administration is then executing the project, ensuring we're fulfilling our obligations but also receiving our entitlements.

So, contract administration, we can break down into two key sets of tasks. We've got business as usual activities. So this covers the sets of activities that are undertaken when everything is going as planned. This means the project scope is unfolding as expected, we're not dealing with any major changes, and both parties are complying with their rights and obligations. Then, the second set of contract administration tasks, we've got change and issue management. This is the management of exceptional circumstances and issues as they arise. These processes arise as a result of changing circumstances, changes to the scopes, changes to the conditions, or poor performance by one of the parties.

So we can break down formation and administration into the downstream and upstream contracts. The upstream contract being the contract with our client, the downstream contracts being the contracts with our supply chain, our subcontractors and suppliers. We've already spoken about, but these are the four different groups of tasks we'll go through during contract management. Tendering is us quoting and negotiating a contract and signing a contract with our client. That's upstream contract formation. Then once we sign that contract, the head contract, we've got head contract administration. Downstream, dealing with our subcontractors, we've got procurement, which is finding and signing agreements with our supply chain. Then once these agreements are executed, we've got subcontractor administration. So making sure we get what we paid for. We're going to cover each of these in a lot more detail, but these different domains all have tools, techniques, and processes we follow.

Tendering, head contract formation, it's about understanding the client's contract, preparing your bid, and negotiating the terms so you can secure a project that you make money on. Procurement. It's about finding the best value for money subcontractors in the market. So, engaging subcontractors, suppliers that match our terms, our conditions, and take on our head contract risks. Head contract administration, it's about managing your obligations with the client, getting your entitlements, and getting extra time and money if the scope changes. Subcontract administration. It's about managing your subcontractors so that they perform and you don't incur additional costs. As we're going to cover in each of the next four sections, the tools and techniques we're going to be learning with tendering, it's contract reviews, how to identify risks, and how to identify qualifications with your bids. Procurement. It's about establishing and writing a good scope of works, taking your head contract obligations and passing them on to your subcontractors, and negotiating and signing subcontract agreements. Head contract administration, it's about maintaining a program, maintaining a variation register, submitting variations, getting variations approved, and keeping good records in a site diary. Subcontract administration. It's about maintaining a program for your subcontractors, coordinating their works, managing any variations and claims from them, and again, documenting and keeping strong records.

So, the first of the four domains of contract management we're going to dive into is tendering, head contract formation. How do we secure the best possible contract with our client? How do we secure a contract at our price with our terms and conditions where we can guarantee we make money during execution? So, head contract formation or tendering, it's about signing a contract that gives us the best possible chance of making money. This is going to be a function of the price and the terms and conditions. The price is what we quote to do the work, what we're going to get paid to deliver the project, but also the terms and conditions, who's responsible for what, how we get paid, the payment mechanisms, whether we're responsible for liquidated damages, what type of security we have to get. We want to basically negotiate and sign a contract that gives us the best possible chance to generate profit. And that's a function of the price and terms and conditions, but also how we strategize and identify opportunities for profit during execution.

Okay, so why is this challenging? Well, first one is that the construction industry is largely commoditized, which means clients are going to three to six contractors to deliver a project. Everyone's trying to give the lowest possible price, and the client is going to choose the cheapest price most likely. On top of that, the client is going to be passing on to us obligations to do the work. There'll be design obligations. There'll be technical obligations. There'll be commercial obligations. And with these obligations comes a large amount of risk if we don't perform. It's going to be a complicated scope. There's going to be lots of different ways, lots of different ways to get caught out. There's a lot of different things we could potentially miss. There'll be complex technical requirements. There'll be requirements to deal with stakeholders. There'll be requirements to get certain approvals to do the work. All of these things make the scope of what we have to do complicated and increased. And when you factor in the fact that it's a commoditized industry and the client's going to be going for the cheapest price, basically we're going to be caught in a situation where it's a race to the bottom on a complicated scope, and it's increasingly likely that we're going to miss things. And on top of that, clients always want you to sign up to unfair terms and conditions. They're always going to be pushing their most aggressive, most unfair contract onto you with heavy liquidated damages, long payment terms, and it's our job to basically work against the forces of the industry and to negotiate the best possible agreement at the best possible price.

Okay, so the first step in the head contract for contract formation process is actually going to be receiving the tender documentation. A client contacts us, they want us to quote on a project for them. This is going to, they're going to send us a package of documentation that includes the drawings, the specifications, the scope of works, contract conditions, schedule, all these things. And this might come from an email or it might come from some sort of tender portal like a Conexus or Felix. First question in contract formation is really going to be, is this a project we want to do? Should we tender for this project? How much competition is there? Is this competition going to drive the price down and force us to take on unfair risks? Do we have a ton of other work going on and we don't have the capacity to manage it carefully? So the first part of contract formation, it's always going to be asking the question, should we tender for this project?

The second part of this process is then reviewing the documentation. We want to perform a high-level review of all the documents they've been provided. The scope of works, is the scope clear? What's included? What's excluded? The program. Can we meet the time frames? Are they very aggressive? Are there major liquidated damages on multiple severable portions? And what are the contract terms like? Are there major risks? Are there the liquidated damages? Do they want huge amounts of security? Do they want to be able to draw down on security without notifying us? When we're doing this, we want to, the key tools we want to create is an RFI or a bid clarification register. So any questions or issues we have, we want to quickly ask them so we can get time frames and responses back in time to support our tender. We also want to start preparing a qualification register, or also known as a departures register. So we want to start listing out all the parts of the contract, the scope of work, tender documentation where we are not going to comply with.

The next part of this process is preparing the estimate. So we need to build up our cost to complete the project. This is going to be based on the scope, quantities, production rates, and any market pricing we've got from our supply chain. There's going to be provisional items. There's going to be items that are excluded. And there's going to be areas of uncertainty and risk that we need to factor in. There's also going to be ways we transfer risk to our subcontractors. So, if we're getting, we have major subcontracts during the tendering phase, we want to basically get our subcontracts in a position where we can sign them as soon as we execute the head contract. So the tools we're going to use to do this will be our qualification and assumption register. This is a really important document because this is going to be the basis of our letter of offer. Any exclusions we're making, any assumptions that we want to document and clarify with our submission. It's going to be our estimate. So our bottom-up direct cost estimate of how much we're estimating it's going to cost us to deliver the project, and also our subcontractor procurement. I can't stress this enough. If there are major subcontracts that we're procuring that we're going to rely on to deliver the project, we want those in a position where we can sign them as soon as the head contract is executed. We have a subcontractor that makes up 40% of the contract value. We rely on them. They've got activities on the critical path. Then basically, we want, if we're signing up to a separable portion or completion date in the contract with heavy liquidated damages, we want to also, and we're relying on a subcontractor to deliver that, we basically want to be signing a subcontract with that same risk transfer, the same completion date, the same liquidated damages associated with it.

Now, once we've prepared our estimate, we want to create our assumptions and qualifications, our departures from the scope of works. What's included in our offer and what's excluded? This is not going to match the scope of works and requirements the client have sent us. We will always have departures, and we need to clearly document what these are. What are we not offering to do? Does the client want us to supply all the permanent materials, but our pricing is based on them free issuing them to us? All of these have to be captured in our departures register. Any key assumptions we've got, are we going to be able to work 7 days a week to meet their program? It has to be made crystal clear to them when we do this. Anything unusual or unclear, any key assumptions we've had to make has to go into our qualification register.

Now, in line with this, so when we've prepared our estimate based on their documentation, we may or may not have reviewed the contract so far, but if we haven't, we need to review the contract terms. We need to do a detailed review of the contract and come up with any terms and conditions that we want to negotiate or depart from. These might be things like payment terms. So they've got 45 days from end of month payment terms, and we're going to have cash flow issues. We'd want 20-day payment terms. If they want 10% security, we might only feel comfortable giving 5% security. Do they have heavy liquidated damages? And because we've developed a program, we've checked, and we've shown we can't meet these dates. All of these have to go into our contract departures register. We have to look at all the terms and conditions, we have to nominate the terms and conditions we aren't happy with. We want to come up with a proposed rewriting of that term.

Now, once we're ready to submit our bid, we've got our estimate, we've checked it, it's correct, we've gone through the scope of works, the documentation they provided, we've prepared our qualification register, we've reviewed the contract, and we've come up with our contract departures. We want to submit our letter of offer. This is our price and our terms to do the work. It's so important. I can't keep stressing this. Your price is one thing. It's the thing your client's going to focus on, but your terms and conditions are the opportunity for you to win the bid. Include your qualifications, your assumptions, any requested changes to the contract, and in your letter of offer, clearly document what your price to do the work is, but what your terms and conditions are as well. Terms and conditions being your qualifications, the tender documentation, and your contract departures.

The next step is to negotiate and sign the contract. Basically, what will happen now is that you've submitted your letter of offer. Your client will come back to say they like your price. They're unhappy with these qualifications. They want you to reprice. You'll go back and forth, go on for ages, but basically, you want to get to a position where you've agreed on both the price, the schedule, the scope, and the contract terms and conditions. To do this, you really want to do a detailed contract review. If you didn't do one at the tender stage, be incredibly happy with what you're signing up to. Critical thing here is that you want to ensure that your qualifications, your letter of offer, make it into the scope of works in the contract. I see it happen an unbelievable amount of times where people submit certain exclusions to scope, but they never follow up and never make sure they make it into the scope of works. So they'll price to do one thing, but the contract they sign says they're going to do another. So you need to ensure your qualifications, what you're negotiating, goes into the scope of works in the contract. The reality is, throughout this entire process, and I say it all the time, is when you're negotiating a contract, everyone obsesses over the price, and they never pay attention to the terms and conditions. The reality is, everyone is going to be focused on your price. Everyone wants the cheapest contractor, but in terms of your ability to make money on a project, your terms matter just as much, if not more, than your price. And in a commoditized industry where there's so much downward pressure on your price, everyone's going to be driving your price down. They'll want discounts. They'll always want to go with the cheapest contractor. If you can understand the terms and conditions and qualifications to scope and how they impact your price, you can negotiate down your price without actually reducing your profit margins. So that's your opportunity to focus on negotiating the terms while reducing your price to ensure you are, in their eyes, the cheapest contractor, but you're still maintaining your terms and conditions so you can make money on the project.

Next up, once we've signed the head contract, we need to talk about procurement, subcontractor formation. How do we find the best possible subcontractors at the best possible price? How do we find the subcontractors we need to deliver the project while also ensuring we get value for money?

Okay, so subcontract formation is the process of procurement. It's the process of engaging subcontractors and suppliers to deliver portions of the project work. It's basically how we transfer our obligations, our responsibilities under the head contract to our subcontractors at the best possible price. We need to find the subcontractors that we need to deliver the works. We also want to make sure we're getting value for money and the best possible pricing from the market. So, what makes procurement so hard? And it is something that most projects stuff up to a certain degree. Well, the first one again, complicated scopes. Construction projects are messy and complicated. There's multiple trades. There's multiple different staging. The methodology impacts the scope. Different.

Vendors impact the pro. The products they choose will impact the scope. There are all these moving parts. And ultimately, nine times out of ten, most construction projects are messy and complicated because they're technically complicated scopes.

Another thing that makes procurement hard is that subcontractors, the suppliers we go to, just know more about the specific scope than you do. If you're going to a concreting contractor for a portion of the works, they'll know a lot more about concrete construction than you ever will. You're buying inverters for a solar farm; you're going to the technical experts on the subject. So, there's this knowledge gap between you and them, and they have opportunities to take advantage of you because they just understand the scope better.

The next one is confusing documentation. By the time you've put together a subcontract agreement, you've attached the scope of works, the drawings, the program, there's just every chance that there are mistakes, inconsistencies, and confusions in the documentation, and there are differing interpretations of the scope between you and the subcontractors, which can potentially lead to variations and disputes down the track.

The last one is that procurement always happens fast. Construction projects are always done incredibly fast. There's a rapid transition from the design going to IFC to needing to get all our procurement done and signing up our subcontractors to starting on site. And often, procurement is the portion of the project that everyone rushes through to basically go from an IFC design to starting on site as fast as possible.

Okay. So, how does the procurement process work? Well, step number one is we need to define the packages. We need to break the job into clear packages of works. For example, for a building, we might have earthworks, concrete, the building, the structural steel, the electrical. There'll be all these defined packages of work we need to complete. These packages are captured in our work breakdown structure, and then within each package, there'll be a set of documents that define the work we're going to be procuring: the drawings, specifications, the project requirements. The tools we use to break the project down and create all our different packages are the work breakdown structure and scope of works documents.

Okay, so once the job is broken down and we've got our work breakdown structure and all the different packages we need to procure from the market, we need to create our tender packages: our detailed sets of drawings and specifications and scope of works documents that define exactly what we want to procure from the market. The litmus test I always use is to put myself in the subcontractor's position. There needs to be enough information in the tender package that if you were the estimator, you could price it. So, for example, if you're procuring concrete construction works, what do they need? They need the structural engineering drawings. They need any concrete specifications. They need the date that they're going to work on site. They need the sequence of the build, what sequence they're getting access to the slabs. Are they doing the detailed excavation? Are they doing the piling? Are they doing the piling breakback? All these things need to be captured in the tender package we send them.

We then send this package of information to three to six subcontractors per tender package. We want to get multiple quotes, so we're leveraging market competition. When I spoke about head contract formation, I spoke about how construction was a commoditized industry. For head contractor formation, that's a negative for us. For procurement, that's our advantage. It's our opportunity to get multiple quotes for a package and to get the best value for money from the market. Then we want to provide them a tender submission date, a date we need their response by. And then we want to liaise with the subcontractors to make sure they understand the information we've sent them and what exactly we're asking for.

Now, once we get our quotes back from our subcontractors, the next step is we want to review and adjust the quotes as needed. When I spoke about head contractor formation, I spoke about departures and exclusions. When we get quotes back from subcontractors, we need to identify these same departures. If we're getting quotes for concrete construction and one subcontractor has excluded concrete pumping, but another has included it, we would need to adjust their quotes and level them. So, we're comparing apples to apples. We use a quote comparison matrix or a tender clarification register to do this. But basically, for the three to six quotes we get, we want to make sure that they're all pricing the same thing. We can either adjust the quotes ourselves or we can send them back to the subcontractors and ask them to adjust them.

Now, once we've got our three to six quotes, we've leveled them, we're comparing apples to apples, we want to select our preferred subcontractor. This isn't going to be just based on price. We're so reliant on our subcontractors to deliver the project that the small savings we'd get by going to the cheapest subcontractor, if we know that they don't have the capability to deliver it, can quickly wipe out the entire project. So, we want to choose a subcontractor based on the value they offer, the capability, whether they can meet the program, what risks they're happy to take on, and also the price. Ultimately, at the end of the day, we want to maximize the value for money ratio. We need a subcontractor who can perform the work safely, to program, taking on certain risks. And we also want to make sure we're getting the best value for money. So, we're also going to negotiate on their price. In the same way we negotiated our head contract, now we need to negotiate our subcontracts. We need to make sure they're taking on all the scope we want them to. They're taking on the terms and conditions, and we've negotiated their price.

Tools we're going to use to do this are the subcontract agreement, so the actual form of contract that they sign, and any internal approvals we need from our own management to sign off on the agreement. Once both parties are happy, we've agreed on the price, the scope, the program, and terms and conditions of the contract, we can sign the contract. Tools we're going to use to do this will be the actual contract form and the agreement checklist. We want to make sure that all of the obligations we're under for the head contractor, relevant to their scope of works, they're signing up to. For example, if it's a subcontract on the critical path and they impact our completion date and we have liquidated damages, we should have liquidated damages in our subcontract.

Once we do that, we can start the process of onboarding the subcontractor and getting ready to deliver the project. Okay, so that's the procurement process from start to finish. It's pretty simple. It's basically the opposite of the head contract formation process. We're on the other side of the fence.

Some tips for procurement are to document everything and make sure what you're agreeing to makes its way into the contract. To ensure your subcontract mirrors your head contract risk, so making sure any obligations you're under for the head contract, for that relevant subcontract, whether it's captured in the drawings, whether it's captured in the contract terms and conditions, you're passing on to your subcontractors. The key here is if you want to go properly back-to-back, you should be starting the procurement process during your tendering phase. So, you should have back-to-back contracts for key packages of work. That means as soon as you sign the head contract, you're signing up your subcontracts. So you're not getting caught between, you're not exposed to some risk that you can't transfer to your subcontractors. Do this by protecting your cost and responsibility by clearly documenting what you're responsible for, transferring to your subcontractors, and starting this process as early as possible.

So, once we've signed contracts, we've formed them, the next step is to administer them. We need to execute the project in line with our obligations and our entitlements. First off, we're going to talk about head contract administration. How do you manage the contract with your client to ensure you make money on the project? Head contract administration is the ongoing administration of the contract with your client. It's about ensuring that you deliver what's required and you get paid what you're entitled to. This means if your client delays you, if the scope changes, you get paid for these changes.

So, what makes head contract administration so hard? Well, first off is the high administrative load. As soon as the project starts getting delivered, you need to start safety documents, quality documents, managing the schedule, dealing with subcontractors. All the administration tasks in the head contract can slowly start to slip. You stop paying attention to records, you stop maintaining the program. It's very easy to stop doing these key tasks. Second one is the risk and responsibility transfer. You would probably signed up to a whole lot of risks, completion dates with liquidated damages, all these things, and you're basically now accountable for everything. The scope, program, and conditions are probably going to be changing continuously. You'll be requested to price additional work. Things the client access dates the client will have given you won't have been fulfilled, and there'll also be strict procedures you have to follow in the contract. If you miss a notice period or a deadline, you might get time-barred and lose your entitlements.

Okay. So, to begin with, the business as usual head contract administration tasks. What are the regular ongoing tasks you need to do day in day out to keep the project moving? First one will be your payment claims. So these are regular monthly invoicing of the client for the work you've completed, and you'll probably need to provide a lot of substantiation to these. Next will be project reporting. You might have to give a monthly report. You might have to give weekly schedule updates. You might have to give records of how many inclement weather days you've been delayed, whatever the contract says you need to report on and to maintain and submit an up-to-date construction program as you work through the project. You'll also have regular meetings with your clients, which for these, you should record meeting minutes and document any correspondence formally with action items and agreed-upon solutions. Again, when disputes start to come up, meeting minutes are unbelievably important. You'll need compliance records. For example, safe work method statements, insurances, quality assurance documents, subcontractor onboarding forms. All of these compliance records will have to be documented and may have to be submitted to the client. And also any requests for information. So, questions to your clients about issues with the design, changes, access dates, all of these RFIs and any communication about change will have to be documented.

Okay, so that's the business as usual tasks. What about when things change? How do you deal with changes and issues? Well, the first one will be extension of time claims for delays. If your client is late in giving you site access, you'll need to claim for more time so you can adjust your completion date. You'll have to put in variation claims, both claims to the client when you think something's changed and requests from the client to do additional work, and also any back charges and credits. When there are quality issues, when there are scope overlaps, the client may try to take work off you or may try to reduce your contract value. So, these are some of the ways the contract can change and what you'll have to continually be working through on the project.

So, when things change, you always have to consider notice requirements. What sort of time frames do you have to give your client? You might have to give them notice within 48 hours. You might have 5 days to do it. And then after that, provide substantiation and valuation of the change. So, you might need records, photos, an impact to the program, correspondence. That's why records matter so much when you're talking about head contract administration and documentation. You always need to be able to prove what you're saying because, basically, construction budgets are tight. Anytime you're trying to claim for more money or time, the client is incentivized to push back as hard as they can.

So, what documentation should you be maintaining? You should always have a variation register. You should always have a delay or event notification template. So, some simple template you can send to your client to say, because of XYZ, we've been delayed as per the original baseline program. RFI registers and claims and correspondence folder. So, tracking all the correspondence about certain claims, if they're approved, if they're not. Basically, what you're trying to do through the head contract administration process is to secure your entitlements, reduce disputes, and protect your margins. If you don't manage this properly, you risk not getting paid for what you're owed. You lose the ability to claim for time or cost. If you don't meet your notice periods, and you absorb risks that should sit with your client.

Okay, so we've spoken about how to manage and administer head contracts. Let's talk about how to administer the subcontracts. How do you ensure you're getting what you're paying for? Most contractors at best leave money on the table and at worst go broke because they don't manage their contracts properly. So, in this video, I'm going to show you 10 contract management mistakes contractors make that can very easily send them broke. These mistakes are going to be broken down into contract formation mistakes, mistakes before you sign the contract, and contract administration mistakes, mistakes during execution of the project.

Okay, so the goal of contract formation is to sign a contract with terms and conditions and a price that gives you the best possible chance of making money. Subcontract administration is about managing your subcontractors and suppliers to ensure they deliver on time, to the specifications, and within the budget, while protecting your own commercial position with your client. It's about getting what you paid for, covering yourself. At the end of the day, depending on the type of project, your subcontract costs might make up 70 to 80% of the total project value, which, at the end of the day, means you're relying on your subcontractors to deliver the project. You need to be managing them properly.

So, the goal of subcontract administration is to ensure subcontractors deliver their scope at the agreed cost, on time, and without exposure to risk. This means avoiding scope gaps or delays, preventing back charges or disputes, ensuring your head contract obligations have been passed on and you're managing those, and maintaining cash flow and commercial control.

So, why is subcontract administration so difficult? Well, at the end of the day, yes, your subcontractors are on site. Yes, you've signed a contract with them, but you're still accountable for the work they perform. If they go insolvent, they go broke, if they decide to get into some huge dispute and they walk off the job, your client doesn't care. It's still your obligation to manage the work. The other reason it's hard is, again, I spoke about the knowledge gap between the general contractor and subcontractor. Your subcontractors know more about the work, and they often will come up with their own strategies to maximize their own profit. And if scope isn't crystal clear, it becomes a battle of assumptions, and they're always going to know the work better than you. They're always going to have their own strategies to make money from variations.

Subcontractors have their own priorities. They might have 10 jobs on at once. They might have another job that's going bad that's taking all of their management attention. They'll have their own priorities, their own separate business with their different interests, which at times, because construction, once you sign a contract, is by definition a zero-sum game. Every dollar you pay them is a dollar you don't get. There is going to be, they are going to have different priorities to you. And again, it comes down to personalities, relationships. You are going to be working very closely with these people, and sometimes you're going to be working with difficult people, people who are adversarial, all these sorts of things. So, subcontract administration can be incredibly hard.

Okay. So, what are the business as usual subcontract administration activities? Well, there'll be, you'll need to onboard your subcontractors. You need to get their insurances, their safe work method statements, organize their site inductions. You'll have regular coordination meetings with them where you go through the program, the access to site dates, how they're going with their works, when they're planned to be finished. You'll have, they'll submit their own payment claims to you for review and approval. You'll assess the works and approve them. They'll be submitting variations to you. So, they'll claim certain scopes have changed, certain things have changed, and you'll need to monitor their performance of the work. Are they on time? Are they doing the work correctly? Is their quality correct? All these sorts of things.

Okay, so what are the core business as usual tools you're going to be using? They'll be things like onboarding checklists, your payment claim assessment templates, subcontractor variation logs, site diaries records, and your construction program. Can't stress this enough. The program is one of the most important contract management tools, both with managing the head contracts and managing all of your subcontracts.

Okay, so those are the business as usual tasks. What about change and issue management? What happens when things change from what was agreed on during contract formation? Well, you might have subcontractors who are underperforming. They might not be resourcing the project properly. They might miss their own start dates. They might have, they might poorly manage the work. They might be late in ordering materials. All these sorts of issues can come up. There might be disputes over scope. They might be claiming things or variations when you don't think they are. They might have defects. They might have rework, and they might not be fixing it properly, or they might be saying it's not their responsibility to fix, or you could have safety or compliance issues. They could be continually performing the works poorly. All these sorts of issues happen on every single project.

Okay. So, how do you manage these sorts of subcontract issues? Well, the first one is going to be notices and back charges. If your subcontractor is not rectifying their defects within a set period of time, you should be sending them notices. If you have had to do work for them, you should be back-charging them for it and setting it off against your payment claims. They're submitting you variations. You should, if you've set up your contracts correctly, you should always have head contract entitlements for variations if you've set up your subcontracts properly. A lot of the time, there will be variations which you can't claim from your head contract, which will have to come out of your contingency. But again, you should be negotiating these variations with the subcontractors. You should be asking for detailed breakdowns, how they've priced it. You should be fact-checking their pricing because they're always going to try and inflate their cost if they are underperforming. And you have to be very careful with this because there's a lot of legal regulations around this, but you should withhold payment if you are entitled to according to the contract. You should always be very fair about how you do this, but it is a negotiation tactic you can use. And you should have clear records. You should have photos, meeting minutes, correspondence trails, everything to back up what you're doing. Again, in line with the contract and in line with what's fair and reasonable. You shouldn't be bullying your contractors and taking advantage of them, but you shouldn't let them take advantage of you either.

Okay. So, what are the tools we commonly use? We use delay notices and templates. We use non-conformance registers. We might be sending our subcontractors NCRs. We might have back charge registers, variation registers, and also, as always, communication logs.

Most contractors at best leave money on the table and at worst go broke because they don't manage their contracts properly. So, in this video, I'm going to show you 10 contract management mistakes contractors make that can very easily send them broke. These mistakes are going to be broken down into contract formation mistakes, mistakes before you sign the contract, and contract administration mistakes, mistakes during execution of the project.

So, the goal of contract formation is to sign a contract with terms and conditions and a price that gives you the best possible chance of making money. First big mistake contractors make is they focus on price over terms and conditions. If contractor A submits a quote for $100,000 and contractor B submits a quote for $200,000, which contractor is cheaper? Well, the obvious answer is contractor A. The reality is you don't actually know the answer to that question until you understand the terms, conditions, and clarifications that surround that offer. The reality is everybody in the construction industry focuses on price. But the reality is contractor A might have submitted a quote, excluded 90% of the scope, not signed up to liquidated damages, want faster payment terms, and have all these other qualifications when contractor B has agreed to do everything in the specifications. The takeaway is because everybody in the industry focuses on price, terms, conditions, and scope is your opportunity. You can be willing to negotiate on price because the construction industry is a commoditized industry. People choose the cheapest contractors. But if you can clarify your terms, conditions, and scope so you can pull down your price but still structure your terms and conditions so you have the opportunity to make money, it will increase the chances of securing profitable contracts.

Mistake number two is trusting relationships over writing. On my last project, we had a fantastic relationship with the client project manager where he'd worked on the pre-contract stage and then was there at the start of project execution. We'd agreed on everything. We started delivering the work, and then the client swapped project managers. They brought in a new project manager who read the contract to the letter, and a whole lot of things we thought we weren't responsible for were not clearly documented in the contract, and he used that to their advantage. So, even though we previously agreed on certain things, they swapped project managers, and then the new project manager led the read the contract to the letter of the law. This is a classic contract management mistake: assuming a good relationship with your client will protect you. And 90% of the time, it probably will. It's the 10% of the time where you're caught out that can lead to real disaster. So, have a good relationship, but also insist everything is in writing and everything is documented crystal clear.

Mistake number three is not agreeing to a program. I'm shocked how many contractors sign up to a contract with heavy liquidated damages without a clear construction program showing them what dates they're relying on to meet their completion date in the contract. Basically, people agree to build something by a certain date without any understanding of what has to be in place to meet that date. If you do this, you're signing up to delays that you'll wear the cost of without any control over them. Key takeaway is a construction program that clearly defines the access dates, what dates you're relying on from the client. It gives you the opportunity to claim delays if you're delayed. So, the construction program is one of the key contract management documents.

Mistake number four is signing up to harsh payment terms. Contractors pay wages weekly. They may have to pay suppliers upfront, but then they sign contracts where they get paid 30 days or 40, 50 days from end of month. Basically, from the day you start the work, you might be 2 months behind on payment. So, basically, you're financing the project. Cash flow is a bigger source of insolvency in the construction industry than the profitability of projects. Don't just accept the payment terms in the contract. Negotiate them and push back on them. Push for 20-day payment terms, cash retention over bank guarantees, interest on late payments, mobilization, and early costs that you can claim in the payment schedule. Anything you can to ensure that you're getting paid before you're incurring costs.

Mistake number five is not getting back-to-back risk transfer with your supply chain. If you're relying on your subcontractors to deliver the project for you and you're not getting back-to-back risk transfer, you're basically signing a contract to guarantee the performance of your subcontractors without any guarantees from them. If prices change or scope shifts, basically your core between and you're going to wear these additional costs. The key takeaway is before you sign a contract with your client, set up your subcontracts, agree to the scope, the terms and conditions, the program, everything you're responsible for from the head contract. Ensure your subcontractors can achieve that. And the day you sign the head contract, be ready to sign up your subcontractors.

Okay. So, avoiding these five mistakes should get you to the point where you've signed a contract, your best possible chance of making money. Next, what can you do during project execution to ensure your project is profitable? The first mistake during contract administration to avoid is never do additional work unless you have a written variation. Multiple times in my career, I've had clients ask for additional work, instruct us to do it, and then when they get the bill for it, to dispute the original instruction. They might think it's all well and good to tell you to do something, but then they're shocked when the bills come in, and they'll clarify that, oh no, they didn't mean that, or no, they didn't actually want you to do that work. And they'll try and get out of paying you for the additional work. If you don't have it in writing, it becomes a he said, she said situation. So, before you do any additional work, make sure you submit a variation, you agree on the price, because once you've done the work, you lose all of your negotiating power.

The next mistake is not getting paid early and often. As soon as you start doing work, put in a payment claim. Try to get paid early and often. Even do a test payment claim so the process is ironed out. There are no issues. So, when you start spending huge amounts of money, you've already got a structure for how to get paid, and you've already worked through the process with your client.

The next mistake, and I'm guilty of having done this multiple times, is not dealing with change as specific issues, but bundling a whole lot of variations together into one big messy claim that gets disputed. I was working on a major electrical job, and there were about 10 changes to the lighting server works. We bundled this together into one big variation claim, and it was a mess. The client suddenly got confused by all the changes. Everyone was confused on what was happening, how it was valued, what the original change was, how the change impacted the price. When you're dealing with variations, it's much better to have a lot of small changes where everyone agrees on the change and the valuation of the change than to try to bundle 10 variations together into one big claim. The key takeaway is submit small, clear variations with specific details on what changed, why it changed, what's the cost impact, and any supporting documentation. It will be so much easier to get these approved.

The next big mistake I see is not maintaining a construction program. As I was saying during contract formation, the program is your tool for claiming additional time and cost if the client is late in giving you access. The only way you can do this is if you maintain an up-to-date and relevant construction program. Update the program weekly. Track plan versus actual. Go through it at your weekly meetings with the client. They'll see you as more professional for doing so. And it will also be incredibly easy to justify any EOT or claims you make.

And the final one that most general contractors are guilty for is letting and forgetting your subcontracts. We sign a contract with our subcontractors. We send them the drawings. We tell them what they to come to site. And then we basically just assume they're going to manage themselves. And a lot of really good subcontractors will. That's basically all you have to do. It's the subcontractors that underperform, make mistakes, and don't manage the work properly that you get caught out for. So, even if you trust your subcontractors, you know they're going to do a really good job, you still need to stay on top of them. If you just assume they know what they're going to do and they don't, you're setting yourself up for failure, rework, and cost blowouts. So, the key takeaway is micromanage your subcontractors. Track everything. How they're going with their quality, where they're up to in the program, what works completed, what's not completed. Go and physically check this for yourself. Check on their safety, how they're performing, and inspect everything. That old saying, trust but verify.

Is it going to rain tomorrow? Does it matter? Well, if you're planning on spending all day inside watching Netflix, then probably not. If you're running a civil construction project that's turning over a million dollars a day, then a day of stand-down due to wet weather is a huge issue. If you've only budgeted for 10 inclement weather days and you're 50% of the way through the project and you've already had 15, then it's a major issue. Uncertainty is unavoidable on construction projects. Everybody knows you need to plan projects. Planning won't separate you as a construction manager. But if you can learn to manage and take accountability for unpredictability and uncertainty, then you're going to put yourself ahead of 99% of construction project managers.

So, in this video, we're going to outline everything you need to know about construction project risk management. We'll talk about why it matters, what it is, the core concepts, the different types of risks you'll face on a construction project, how to manage risk on a construction project from end to end, how to deal with the specific environmental, health, and safety and cash risks, and finish off with a case study where we explore applying these concepts in practice.

So, let's start off with an all-important question. Why should you care about risk management? Well, the first thing I want to establish is that planning is the baseline. 98% of project managers create a plan for their project. Yet, only 48% of construction projects finish under budget and ahead of schedule. Why? Well, a plan tells you what should happen given our assumptions and our planning is correct. But given such a small percentage of projects achieve their objectives, we can see there's a huge difference between the way people plan and the way projects are delivered in practice.

So why do plans fail? Well, for a simple reason that construction is unpredictable. We get weather conditions we never could have planned for. We get scorching hot days, heavy rains, or strong winds that cancel crane waves. We get supply chain disruption. We get late delivery from suppliers or key subcontractors going broke. We get site conditions that we couldn't have prepared for. There might be unknown utilities or poor geotechnical conditions that screw up our earthworks productivities, and we get people issues. We get labor shortages or disputes with subcontractors. Every plan we create relies on assumptions around these core variables that always end up being different to what we planned for.

On top of that, because the construction industry is so heavily commoditized, meaning the cheapest price tends to win, the subcontractor or contractor who makes the most aggressive assumptions around these unknowns tends to be the ones who get the job. Meaning, the person who underestimates the risk is often the one doing the project. This leads to a set of circumstances and an environment that makes effective risk management incredibly difficult. You can plan as much as you want, but planning alone won't protect you if your assumptions are wrong and you have not prepared for uncertainty. Excuses like "we were late because a key supplier failed" just aren't good enough. And the best construction managers accept, prepare for, and deal with uncertainty. They take accountability and ownership of it through effective risk management. And the evidence supports this. A big study by McKinsey found that effective risk management is one of the key drivers of successful project delivery.

You can think of it like this. Planning develops a road map for how we're going to deliver the project, and risk management protects this road map. It involves several key actions, including identifying possible risks, possible sources of uncertainty that matter, assessing their impact and likelihood, developing response plans such as avoiding, reducing, transferring, or accepting, and monitoring and updating this risk management plan continuously. Fundamentally, effective risk management is about resilience, not prediction. You can't predict everything that's going to go wrong, but you can be ready for it. A study by the PMI found that effective risk management can reduce the impact of unpredictable delays by up to 20%. Risk management protects your profit margins, keeps your schedule realistic, reduces costly disputes with subcontractors and suppliers, and enhances safety and compliance. Without it, we'll blow our budgets, miss deadlines, suffer quality issues, and damage the relationship we have with our key clients. Planning tells you what should happen. Risk management prepares you for what might happen.

So now we understand why risk management matters and why you need to be able to deal with uncertainty to be an effective construction project manager. Let's get into the nuts and bolts of the topic and start by talking about what is risk management. So, put simply, risk management. What is it? Well, it's the process of how we take uncertainty and turn it into manageable action. Risk management is the structured approach of identifying, assessing, treating, and monitoring uncertainty that may affect our project goals. Project goals could be anything like cost, time, quality, scope, safety, reputation with the client. So, risk management is the way we address the sources of uncertainty and how they impact these goals. It allows us to turn uncertainty into manageable action.

Okay. Intrinsic to this definition of risk is this term uncertainty. So, it's important to distinguish between what's a risk and what's uncertainty. So, all risks are uncertainty, but not all uncertainty is a risk. What do I mean by this? There's uncertainty in everything and everywhere in what we do. Who will win the lotto tomorrow? What is the weather going to be like in Greenland? And what will our production rate for trenching be? These are all sources of uncertainty. The difference is that what our production rate for trenching is a risk for the project. A risk is a source of uncertainty that matters. So, any risk has to have two components: it needs to be uncertain, and it needs to matter, meaning it needs to impact the project goals. So, risks are specific uncertain events or conditions that could impact the problem project objectives. Importantly, as well, is that if something has happened, it's not a risk. If we know our production rate is lower than what we planned for, it's not a risk because it's not uncertainty. It's a known, it's a known issue we need to deal with.

Okay. So, next up, we've got this idea of a threat versus an opportunity. So, it's important to understand that risks are not always bad. How much is it going to rain tomorrow is a risk. It's a source of uncertainty that matters and it will impact the project objectives, but it could be both a threat, meaning it has a negative impact on the objectives, or it could be an opportunity. If we have a contract signed where we're allowed to claim additional cost and time for any inclement weather, then it would be an opportunity. We're going to get paid extra to deliver the same project scope because we're delayed by poor weather. If, however, we've got a fixed budget for inclement weather, and if we go over that, we have to wear the cost of that, then by definition, it's a threat because it's going to negatively impact our project objectives.

Okay? So, the goal of risk management isn't just to deal with the negative consequences. It's also to increase the chance of our opportunities happening. So, on one side, we're trying to eliminate or reduce the impact of our threats, but we also want to increase the chances of our opportunities happening.

Okay. The next thing I want to talk about is basically defining some of these key terms around risk. So, we've got a cause, a risk event, and consequence. A cause is a condition or trigger that makes the risk possible. For example, extended heavy rain could be a cause of our inclement weather risk. The risk event is the uncertain event itself. For example, the concrete pour being delayed because of the poor weather. And the consequence is the impact on project objectives if it happens. So, for example, if excess heavy rain, the cause, delays our concrete pour, the event, then the consequence would be the project timeline extended by 3 days. Clarifying and understanding these definitions helps you understand a bit more about risk management.

Okay. Let's look at another example. So, we've got a key subcontractor is in financial stress due to underbidding multiple projects. That's the cause. The risk event is the subcontractor going into default in the middle of the project and not being able to finish the work. The consequence is then the immediate need to find a replacement, resulting in increased cost because we would have to quickly procure someone from the market, delayed because there'll be a period of time where we need to find the additional subcontractor, and potential legal dispute. That's another example of a risk where we've got the cause, so the subcontractor being in financial stress, the consequence, or the risk, sorry, the risk event, which is the subcontractor going into default, and then the consequence, which is the impact of the additional costs and time to find another subcontractor.

Looking at another one, we've got design changes. So, the cause: the client's approval was pending with last-minute conditions, and we didn't get it properly signed off before we needed to start work. The risk event is the approved design may need some sort of redesign due to clashes with the facade layout and the mech and plumbing. Consequence would be redesign work, additional procurement, additional rework on site, cost overruns, and so on and so forth. So, that's another example where we've got the cause was poorly coordinated design where the client didn't sign off in time. The risk event was the approved design may require some sort of changes post IFC, and then the consequence would be additional cost due to the rework.

Okay. So, now we understand a risk event, a cause, and a consequence. Let's actually talk about the risk management process. What is the process that we follow to increase the chances of our opportunities happening and reduce the chances of our threats? So, it's a four-step process which starts with identifying our risk. We need to systematically find the threats and opportunities to the project. And we can do this using brainstorming, so group brainstorming sessions, lessons learned, or expert input. So, the best source of risks I've always found is people who've delivered similar projects. They have a good understanding of what can go wrong.

Once we've identified our risks, the next thing is we need to assess our risk. We need to analyze the likelihood of them occurring and the impact if they do occur. Basically, this is going to help us prioritize what risks actually matter. Where should we be putting our limited time and attention? Step three is then we need to plan. So, we need to prepare for our responses. So, basically, what are we going to do to address each risk? So, for our threats, the negative risks, we can avoid them. We could change the plan to remove the risk. We can mitigate them. We could take steps to reduce either the likelihood of the risk occurring or the impact if it does occur. We could transfer this risk to a third party through a subcontract or through insurances. And if they're not significant or not a big impact, we could just accept them and choose to do nothing. For opportunities, we want to exploit them. So, take steps to ensure that they happen, enhance them, increase the chance that they're happening or the impact if they do. Share them, partner with someone to increase the chances of them happening, and accept them, take advantage of it happens but not take any steps to increase the likelihood.

Then step four is the iterative nature of it where, as we go through the project, some risks will eventuate, some will be closed off. We basically want to continually monitor, review, and update our risk register, add new risks if they occur, and update the plan if things change.

Okay. Next important concept is a risk register. So, the risk register is the principal tool that we'll be using throughout the project to track, monitor, and update our risk. This is the source of truth for uncertainty for the project. So, a risk register is basically a live log of the identified risks, the causes and consequences, the assessment, so both the assessment of the likelihood and the impact, the treatment actions, what we've decided to do about it, the owner, who on the project team is responsible for the risk, and the status and updates. And basically, it ensures none of our risks are forgotten. We're keeping track of them, and it's clear who's responsible for what.

Okay. The final concept around risk management are risk tolerances. Okay. So, a risk appetite is how much overall risk the organization is willing to accept in pursuit of their goals. It's going to depend on a lot of different factors such as the size of the project, the dollar size, particularly if it's a huge project and it goes bad, that's going to have a much bigger impact on your organization than if a small project goes bad. But also the risk tolerance. So, how much variation from the plan is acceptable before action is needed. These help decide which risk to treat and which to accept. So, for example, we could see that a company that's willing to pursue a solar farm engineer, procure, and construct contract where they're taking all the risk of changing material prices, the installation costs, the performance of the plant, is a very different risk profile to a small asphalt job. It's done on square meter rates where they, where the organization is not even taking the quantity risk. So, you can see different organizations have significantly different risk appetites and tolerances.

Okay. To summarize, risk management is about seeing uncertainty clearly, understanding what could help or hurt your project, and having a plan to handle it so you stay in control, protect profit, and deliver the project successfully regardless of the uncertain events and conditions that can impact the outcomes.

So, now we understand some of the core concepts around construction project risk management. Let's talk about the different types of uncertainty. In this section, I really want to broaden your understanding of what a risk is and all the different sources of uncertainty on a project. So, let's explore the different types of risks and how to group them. Really want to give you a framework for thinking about all the different types and forms of risks that exist on projects.

Okay, so the first grouping is event versus non-event risk. So, an event risk is a discrete, identifiable event that might happen. For example, a subcontractor going broke. These are typically what we think of when we think of a risk: a discrete, identifiable event. However, it's not the only source of or type of risk on a project. Non-event risk is variability from our assumptions when no single trigger triggers happen. And these are critical to understand on construction projects because they exist everywhere. Our, for example, our actual concrete placement productivity is lower than expected. Our actual rainfall is much higher than what we thought it would be, or our production rate for trenching is different to what we planned. These sources exist everywhere and they describe all the different assumptions we need to make. Now, we try to improve the accuracy of our assumptions, but at the end of the day, through our estimate, through our schedule, there are assumptions built into these, and these sorts of non-event risks exist everywhere. In the pinach, these are called variability risks. So, the key takeaway here is to effectively manage our risk, we need to consider what could happen, so a specific event, but we also need to consider what could be different to what we assumed, a non-event risk.

Okay. So, the next distinction I want to make are between known risks and unknown risks, referred to as black swan events. So, a known risk is a risk we could reasonably foresee based on our past project experience, the experts in our team. These are things we can identify and then plan for. If someone's working at heights, we know that there's a potential that they could fall. So, that is a risk we need to address. A black swan event, also referred to as an unknown or unknowable risk, are risks that are unexpected, highly unlikely, and beyond normal prediction. For example, the classic that everyone talks about now is COVID-19 shutdowns, where there was this sudden huge pandemic. It was unpreped. There was nothing like it before. You can't plan for specific black swan events. But, and this is the important point, is that you can develop project resilience. For example, having contingency funds set aside, having flexible contracts, good communication between our subcontractors, suppliers, and stakeholders, and strong relationships all help to this idea of project resilience. But we're not planning for a specific risk because it's, by definition, we can't know it's going to occur. Rather, we have a resilient and flexible approach that we can adapt if some sort of uncertain event or condition occurs.

Okay. Next, let's talk about some common ways to group risks and the different categories. So, these are typically what we think of when we think of different categories of sources of risk. So, first up, we've got technical risks. So, technical risks are things like incomplete designs, design errors, or incorrect specifications that impact more of the engineering side of the construction. We've got project management risks, so poor planning, unrealistic schedules, scope creep. We've got contractual or commercial risks, such as unclear.

terms, the potential for claims and disputes. Got financial risks. So these are budget overruns, funding delays or cash flow issues.

Supply chain risk. So this is where we get late materials. We get subcontractors going broke or price fluctuations between when we negotiated contract when we signed it and when we needed to order the materials.

Got construction risks such as productivity shortfalls, equipment breakdowns, and rework. Got external risks such as poor weather, environmental conditions or regulatory changes. Got stakeholder risks such as client disagreements or community objections. And then we've got health, safety, and environmental risks such as accidents, pollution, or non-compliance fines.

We can also group our risks by consequence. So we could have cost risk which is a budget overrun, unexpected reworks, claims from subcontractors. You could have schedule risks, so delays, waiting on approvals that delays the schedule, productivity shortfalls. Could have quality risks such as defects or non-conerformances. We could have safety risks such as injuries or lost time incidents. We could have environmental risks such as spills, erosions or regulatory fines. We could have reputation risk. So this is where the client is dissatisfied or we get negative publicity.

And then the final way we can categorize our risks is by ranking them in terms of their impact on the project. So the impact on the project or the potential impact on the project is going to be combination of the likelihood, the probability of the risk happening and the impact if it does occur. This sort of matrix you'll see everywhere on construction projects and it's two it's a ex two-dimensional matri matrix that is where we classify a risks qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qu qualitatively based on their impact. So whether they're negligible, minor, moderate, significant or severe and the likelihood of where they occur. So very unlikely to very likely. We can see if something's very likely to occur and very severe if it severe if it does occur. And that's where we need to be putting our time and attention when if something is negligible, if it does occur, and very unlikely, then it's not worth our time and effort.

So, now we've got a good understanding of the different types and categories of risks that exist on construction projects. Let's dive deeper into how to specifically manage risk on a project. So, the risk management process is a structured systematic method for dealing with uncertainty on a project. It ensures you spot risks early, understand their importance, have a plan to deal with the important risks, and then monitor and update your risk register continuously. So as the project progresses and things change, you stay on top of the uncertainty that matters.

So most international standards, project management bodies break it down into four main steps. Step one is to identify risks. Step two is to assess the risks. Step three is to plan our responses. And then step four is to monitor and review and iterate on the risk management process. Okay.

So step one is to identify risk. What it means basically it's to systematically find and record all the sources of uncertainty both threats and the opportunities that can impact your project. How do we do this? We brainstorm with the project team. We use checklists and reviews from last projects and lessons learned. We talk to our stakeholders. We review the contract conditions, the design drawings, site reports. We engage with experts who know what they're doing and have worked on this exact type of project. For example, during planning, the team identifies that the schedule concrete pores are planned during the region's peak rainy season. They also notice that the supply contract depends on a single steel supply. So, they've identified two main risks for their project. heavy rain that may delay the concrete works, which is a threat. A sole steel supplier that may cause delivery bottlenecks, again, a threat. And if potentially an opportunity where the weather is unusually dry, pores could progress faster than planned. Now, this is broken down into event risk, but you could also categorize this as a variability risk where we've got a set assumption of how much inclement weather we think there's going to be and that assumption may be lower or higher than what we predicted.

Step two is we then need to assess the risk. What this means is we need to analyze for each risk how likely is it to happen and how big will the impact be if it does occur. We can do this qualitatively using categories like low, medium, or high like the risk register, the risk matrix I showed you in the last section. Quantitatively, if we've got good data, we could actually calculate these numbers specifically. For example, we could do look at how much it's rained over the last 10 years, how variable that is, how accurate our assumptions can be, and then we rank our risk. So basically, the high impact, the high probability risks are the ones we focus on. For example, the risk rain delays, the likelihood's high and the impact is medium to high. It could push our schedule up 5 days. We prioritize this as high. Our steel supply delay, the likelihood is medium, the impact is high. So then we rank the risk high. And dry weather that speeds up the pores. Let's say the likelihood's poor because we've looked at 10 years of historic weather data and it never rains less than what they think it's going to rain. The impact is medium. you only get minor cost savings. So the priority is therefore low.

Okay. So then step three is to plan our responses. What this means is we decide what action to take for each of our risks. So for our threat, our options are to avoid the threat, mitigate the threat, transfer it to another party or just accept it. For opportunities, we can exploit them, enhance them, share them, or accept them. How do we do this? Again, we use brainstorming, looking at all the different practical applications. We assign an owner to each. Again, this is critical because we have to treat risks and risk responses in the same way that we would treat any task in the project. Someone needs to be responsible for it happening. And then we update our plans, budgets or contracts if required. So, for example, rain delay, we've categorized as a high risk. So, we're choosing to mitigate it using faster concrete curing concrete mix, installing temporary weather shelters where it's possible, and sequencing the pores to allow flexibility. The owner of this risk is the site manager. The steel supply delay, we want to transfer and mitigate this. We want to add in a backup steel supply to the contract and order the critical sections of steel earlier. So, we're both mitigating the risk and then transferring it to a supplier. The owner will be the procurement manager to ensure that's how the supply contract with the with the steel supply is written. Then for the dry weather opportunity, we want to enhance it basically by just having a contingency crew available that if we get particularly good weather, we can bring in extra resources and we can finish the works as quickly as possible. The owner is going to be the project scheduler.

Then step four, we've got our continuous iterative process. basically just monitoring and reviewing the risks and keeping them up to date. What this means is we kept keep track of the risks throughout the project. We ask ourselves our treatments working has a risk changed and a new risks appearing that we need to assess and identify and plan responses to. Basically, how we do it is we'd set a weekly or monthly catchup meeting depending on the duration of the project and how important the risks are. And we just go through the risk register. We go through every risk and look at all the information in it and ask ourselves if it's still relevant. We also want to hold regular meetings to brainstorm and identify any new risks that are cropping up. So, for example, our construction manager monitors the weekly weather forecast and plans the concrete pores around when it's likely not to rain. The procurement manager tracks the steel supply deliveries to ensure the supplier is on track and if there's delays the main steel supplier they get their backup supply ready. So it's basically just the process of checking our response is working things changing can we close off risks and so on and so forth.

Okay. So why does this four-step approach work? Well, it ensures we start early. The earlier we identify the risks, the cheaper and easier it is to manage them. It's a consistent concept in construction management that the earlier we address an issue, it's generally much cheaper to fix. We assign clear owners. We treat risks like any other task in the project and we assign someone to manage them. We keep it live because this is an iterative approach and we're going through it and continually updating it. We track it and manage it as the project progresses and we also communicate effectively. We share our risk updates with our client and key stakeholders. So we ensure there's no surprises and we keep them on board and supportive of the project. If something changes outside of our control, least we can say we had a plan and did our very best.

How do you manage risk on a construction project? Working on a project, it's not a question of if risks will eventuate. It's a question of when they'll eventuate and how prepared we are to deal with the projects that implement risk response strategies are 58% more likely to finish on time and 43% more likely to finish under budget. As a construction project manager, if you can master project risk management, it is an undisputable fact that your projects will be more successfully and ultimately your career will be more successful. That's why in this video, we're going to look specifically at risks on construction projects, how to manage risk, the process to follow, how to use risk management to become a better construction manager.

Risk is the uncertainty that matters to the projects. It's the things we don't know about, the uncertainty in our plan, and the uncertainty that can impact the outcomes of the project. So when we say risk matters, we're saying risk has an impact on the objectives of the project. What are these? So it could impact the health and safety of anybody working on the project, the impact to the environment, could have an impact on our cost, our budget, could have an impact on the time it takes to complete project. And could it also have an impact on the perception of the project from our stakeholders?

When talking about risk on construction projects, we can group these impacts into two separate categories. We've got our zero harm goal and we've got our project success goal. So, when we're talking about zero harm, we're talking about eliminating any harm to people or the environment. Now, this is an ethical responsibility. It's not about making more money. It's not about making people happy with delivering the project. It's about keeping people safe and avoiding any sort of environmental harm. So this is an ethical responsibility that we have as construction project managers. The other side we've got our project success factors. So we want to make sure the project is a success financially and also finishes on time.

So when we're talking about project risk management, talking about the process of conducting risk management, planning, identification, analysis, response planning, and control on a project. What does this mean in practice? Well, it means we're increasing the likelihood positive events by exploiting opportunities and decreasing the likelihood of negative events by eliminating the rates.

Okay. So now we've established what project risk management is in the context of construction projects. Let's go on to talking about the different categories of project risks. So when we're talking about risk categories, we're talking about the categories or the groupings of uncertainty that impact objectives. On construction projects, we've got the following categories of risks. We've got technical risks, construction risks, health and safety risks, environmental risks, commercial risks, and external risks.

Okay. So the first one are our technical risks. What are these? These are risks to do with the development of the project technical solution. So making sure that what we build can work and operate correctly. So for example, these would this might be something like this designing the strength of a building foundation to meet the earthquake requirements or designing a HVAC system to ensure it meets the climate control objectives of the building.

Okay. Once we develop the technical solution to the project, construction is the process we go through to create the design to deliver the project in accordance with the drawings and specifications. There's a lot of uncertainty in this process. We can have issues with coordinating subcontractors. We can have delays in materials or we can have poor workmanship resulting in defects and rework. So construction risks are uncertainties in the construction process that can impact the objectives of the of the project.

Throughout the construction process, we have the risk of harming workers or members of the public while completing the construction activities. Construction projects are dangerous. We might have to work at heights. We'll be completing crane lifts. We could drop things. We could strike inground services while excavating. There's a lot of uncertainties throughout the construction process that can have a significant impact on people's health and safety. And in the same way that we can have health and safety risks, we can also have environmental risks. So we could have an oil spill. We could have polluted water running off into a waterway. We could remove native protected vegetation without the appropriate approvals. So we could have all sorts of environmental risks while we're completing the construction project.

Now tied into all of these other risks, we can also have commercial risks. So these are risks arising from our contractual rights and obligations. So we could have a dispute with our client. We could have a dispute with our subcontractors. Our client could be delayed in paying us resulting in cash flow issues or we could be late in finishing the project and incur liquidated damages. In the final category, we've got external risk. So we could have risks arising from our stakeholders or impacted third parties. So we could be prevented in accessing the work site because we have to go through private property or we could have a utility not giving us approval to complete construction excavation near their underground service. So we can have our works impacted by the actions of third parties.

Okay. So we've established what project risk management is and how it relates to construction projects and we've also spoken about the different categories of risks on construction projects. Let's now talk about the risk management process in construction. Okay. So here we've got an overview of the risk management process. The high level the risk management process we follow is we establish the context. We understand what's important to the project. We identify our risk and opportunities. Then we analyze, evaluate and treat them. And then throughout this entire process we're continually monitoring and controlling to ensure the risk management process is working as planned. Then we're also communicating with our stakeholders, those impacted by the project, so they're aware of the uncertainty that matters to the project.

Okay. So first off, we need to establish the context. Okay. So first off, we need to establish the context. What do we mean by saying establish the context? Well, we want to tailor the depth and complexity of the risk responses to the specific characteristics of the project we're working on. There's a cost associated with the risk management process. It takes people's time, takes resources, that costs money. On top of this, there's a law of diminishing returns. The more effort we put in doesn't won't necessarily result in better outcomes. We want to tailor the risk management process to the specifics, project risk, the project specifics. On top of that, we want to understand our specific project risk thresholds. If we're working on a $10 billion project, a $2,000 cost blowout on a material order isn't a big deal. If we're working on a $20,000 minor home renovation, then a $2,000 cost blowout is a pretty big deal. That's why for any specific project we're working on, we need to understand our risk thresholds. What are considered important risks? What are considered unimportant risk? These are going to come, we can group these into three categories, safety, schedule and cost. And for our specific project, depending on the size, nature of the project, we want to come up with a scale of low, medium, and high for the specific project risks. Okay. So we're talking schedule. We could say for our project, a delay of 0 to 5 days is considered below risk. A delay of greater than 20 days is high risk. can do the same with our cost to come up with different categories of impacts.

Okay. So once we've established the context, we understand the specific project thresholds, the context with which we're going to apply the risk management process, the next thing we need to do is we need to identify the risk. We need to identify the sources of uncertainty that matter to the project. It's critically important when we're identifying risks that we're identifying risks. We're not identifying causes. We're not identifying impacts. And we're not identifying problems or issues. When we define a risk, for any risk, we should be able to express it in the following sentence. As a result of a specific cause, an uncertain event may occur which would lead to an effect on objectives. As an example of this, we've got as a result of latent site conditions, excess contaminated soil disposal may occur, which would lead to increased disposal costs. So, we've got the cause, which is latent site conditions. We've got the risk, which is excess disposal of contaminated soil. And we've got the impact, additional disposal costs.

So, how do we identify these sources of uncertainty amount? Well, there's three ways we can do this. We can look at the past, so what has happened on previous projects to give us an indication of what risks may eventuate in our project. We can look at present. We can talk about what we're currently exposed to. We can talk about the future. What could go wrong? We could use brainstorming. So using these three broad buckets of past, present, and future, some techniques we can use that integrate these. So we can look at lessons learned from previous projects. We can talk to subject matter experts. So people who've got experience delivering the type of projects we're working on. We can use checklists. So a checklist would capture a supererset possible risks we're exposed to on the project. We can look at contract analysis. So we can look at the specific contract we've signed and look at what risks we're exposed to in the contract. We can look at other sources of documents that might give us an indication as to potential sources of uncertainty. And we can use brainstorming. the the output of the identify risk process is going to be the risk register. This is where we document all of the different types of project risks we're exposed to. So for example, the excess contaminated soil, the design solution failing to meet the client requirements or additional scope that we haven't budgeted for. We'll categorize these risks. We'll describe these risks and we'll talk about the effect.

Then we need to analyze these risks. So we've identified all the sources of uncertainty that matter. Now we need to analyze them. We need to work out which of these risks matter. Now there's two ways we can do this. We can use a qualitative risk assessment or we can use a quantitative risk assessment. So a qualitative risk assessment is a subjective risk assessment where likelihood and impact are categorized using our risk threshold. So low, medium or high. Quantitative risk assessment is where we use verifiable data to assign a specific numer numerical cost or delay to each of the risks.

Okay. To complete a qualitative risk assessment, we go through each risk in our risk register and we give it a probability and an impact. So a probability is a chance of occurring. An impact is the result if it does occur. This can be in terms of how much it will cost if it eventuates, how much it will delay us or what sort of health and safety consequence we'll get. Across these two dimensions, we'll categorize these into our risk thresholds and then give it a risk rating. So the risk rating is the product of the probability and the impact. This means high probability, high impact risks will be given the greatest score with low probability and low impact risks given a lower score. Then each of our risks we can score based on these two underlying characteristics. How likely they are to occur and what happens if they do occur. So a risk that's almost certain to happen and catastrophic if it does occur would be an extreme risk. A risk that is unlikely to occur and low impact if it does occur would be a low risk. Now, this is an important exercise to do because it allows us to get a holistic view of which are the most important risks to the project. Where should we be putting our time and attention? We're going to summarize all of this information in our risk register. So, against each of the individual risks for the project, we've given it an impact level, a prob probability level, and then we can give it an overall risk rating.

Okay. So we've spoken about how to do a qualitative risk assessment which ultimately comes down to some sort of subjective judgment as to the impact and likelihood of each of the risk. The other way we can do this is with a quantitative risk analysis. So we can look at all the risks in our schedule and we can assign a numerical value to each of them using data to support us. So we can do this at the micro level where we look at an individual risk and score that risk based on an underlying calculation or we can look at a macro level where we look at the overall impact of risk on the project outcome. So we do this in terms of schedule calculation or a budget calculation. So the benefits of a quantitative risk analysis is it actually gives us a specific probability of achieving each of the specific project objectives. So we can develop what's referred to as a P50 schedule. So an anticipated finish date based on a 50% likelihood. It also allows us to identify realistic project ts and give us exact values for different project risks and to also help us analyze the cost of risk responses versus the benefits.

Okay. So now we've analyzed our risks. What do we have to do next? We need to evaluate which are the most significant and important risks on the project and then we need to do something about them. So the important risks will choose to develop a treatment in response to a risk. There's several different things we can do. We can do nothing. We can ignore it. It's small. It's insignificant. We choose to do nothing. We can treat the risk. So we can come up with some sort of plan to mitigate the risk. So this means reducing its likelihood or reducing its impact if it does occur. We can undertake further analysis and investigation. Maybe we decide we don't have enough information to perform a proper judgment or proper significance analysis. If we've already got some controls in place, we can simply maintain the existing controls or in certain circumstances, we can actually reconsider the objectives of the project. So we can change what we're choosing to focus on and how we're defining project success. So a risk treatment is taking some form of action in response to the risk to reduce the threat or maximize the opportunity. This is the essence of project risk management. If we're not treating our risk, if we're not doing anything about them, none of what we've done so far matters.

Okay. So what treatments do we have available for any risk or we can avoid or exploit the risk? This means eliminate the risk or make the opportunity definitely happen. We can transfer it or share it with another party. So we can involve another person or party in the risk. For example, if we're exposed to inclement weather, we could transfer this to our subcontractor. We can reduce or enhance the risk. So reduce the threat or enhance the opportunity or we can accept the risk. We can just accept the risk as it is and choose to do nothing about it. So what's the optimal strategy? The optimal strategy is going to depend on the specific risk, its likelihood and impact, its risk rating, its urgency, so how quickly we need to do something about it, its manageability, how what can we actually do about it, and its propquity, which is a fancy way of saying how in control are we of the risk and also the cost of the risk response.

Okay, there's a continual problem that project managers have where they make plans, they work out what to do, and they never do it. And it's highlighted by this age-old riddle. If there's five frogs on a log, and one of them decides to get off, how many are left on the log? Well, the answer is five. One of them decided to get off, but they didn't get off. Project risk management is worthless if we don't do anything about it. If we don't implement the risk response strategies we've come up with, this goes for any project management process where we develop a plan, we decide what to do. If we don't actually do it, then all the planning we've done has no value. To get anything out of this process, we need to implement our risk responses. Best way to do this is just to treat them as project task. Define the scope of the task, the duration, the budget, the completion criteria, and give them an action on it. allocate the responsibility of implementing the risk response to an individual on the project team and follow up to make sure they do it.

Okay, let's talk about our contaminated soil risk. So, we're responsible for dealing with contaminated soil in our project, but we don't know how much contaminated soil there is. So, what do we decide to do? We decide to manage the risk. We want to transfer this responsibility to a subcontractor. The timeline for implementing this risk response is the procurement phase. By the time we sign a contract with our subcontractor, we need to have agreed on a way of transferring this risk to them for the budget of $30,000. So, we've got contingency funds of $30,000 set aside. And the responsible person for ensuring this happens is the Earthworks package late. to the one preparing and managing the procurement of the earthworks contractor. To successfully implement any project risk response, it's all about having a controlled response. We just need to treat the risk response strategy as any other project task. This means we need a clear plan of how it will be implemented. We need a known deadline for implementing it. We need to reassess the plan if it's not being followed to understand why. We need a budget and a duration. We need a responsible person. And then if we're not successfully implementing the plan, we need to go through a change management process. The essence of risk response implementation is just treating it like any other project task.

Throughout this entire process, we want to be man monitoring and controlling the process to making sure everything's being followed correctly. We're following up and we're identifying any new risks as they arise. Risk management is an iterative process. We're going to be cycling continually through this process throughout the duration of the project. There's lots of different ways we can do this. We can do process reviews. We can make sure we're regularly iterating through the process. We're following through meetings. We can audit our policies and procedures. We can deal with changes as they arise and assess these in terms of their risk. We can look at outcomes of the project and identify certain trends like areas where we're overspending the budget. We can look at specific incidents and we can also communicate and engage with our stakeholders. The key is when we're talking about monitoring, controlling risk management is just to iterate through the risk process. Iterate through the entire risk management process. You constantly want to be cycling through identifying, analyzing, evaluating, treating, and then assessing how effectively these treatments are working. Simplest way is to set a regular meeting in your calendar, whether it's weekly, fortnightly, monthly, and identify and treat any emerging risks and look at the current status of our existing risks.

In summary, risk is the uncertainty that matters to the project. Risk management is the process we go through to eliminate threats and exploit opportunities. It's a series of steps we follow both at the beginning of the project and iteratively throughout the project. And risk is a reality of projects. It's not a question of if a risk will eventuate, it's when and how prepared we are to deal with it. As construction project managers, we have an ethical responsibility to ensure the safety of everybody working on our projects. Other project outcomes like cost or time are an important part of our jobs, but safety is different. Making sure nobody gets hurt will always be our number one priority. If we can't do it safely, we don't do it. It's as simple as that. That's why in this video, I'm going to talk about how to manage health, safety, and environmental risks on construction projects. I'll talk about what a health and safety risk is, why they matter, and how to manage them.

I want to start with a simple example. Looking at the picture on screen, what hazards can you see? Even in this picture, there's a surprising amount of hazards. There's traffic. You could have someone crash into the construction site. They could be underground services like gas or electricity that we dig through. They could be people working around the excavator leading to people and planet interactions. You could have dropped objects from people working above. You could have a structure collapse. You could have machinery fail. You could have tricks with all the objects on the ground. Or you could have an oil spill that goes down the drain. In any construction project, there is a huge amount of different hazards that we need to be aware of and we need to manage. With all these different hazards, as construction managers, our role, our responsibility is to make sure the activity is safe enough to do that we can be confident that nobody's going to get hurt while doing it. That's where the ethical responsibility of construction management comes in.

Okay. So let's define health and safety risk management. So health and safety risk management is the process of managing construction activities to eliminate or minimize as far as reasonably possible the risk of injuries or fatalities. So an example of this would be working at heights would be using scaffolding and a harness so we can safely complete any works at heights. Another example could be temporary electrical equipment we have set up around the construction site. So, we could use routine inspections by a qualified electrician to ensure that there's going to be no electrical faults and the equipment is continually safe to use. And more generally, we could have regular toolbox talks with the workers to make sure they're aware of the different risks on site and they're constantly paying attention to and focusing on safety.

Now, managing all of these separate hazards, all these separate risks is the fundamental ethical responsibility of a construction manager. What I mean by this is while managing cost, managing schedule is fundamental to your job role. And if your projects below their budget, then you're not going to be able to work as a construction manager for long, it's still a part of your job role. Health and safety is different. Health and safety is an ethical responsibility. you're morally obliged to make sure that the people working on the project are safe. The fundamental principle behind health and safety risk management is if the job can't be done safely, then we don't do it. It's as simple as that. The key thing we need to understand though is how do we know if a job can be done safely? What does that mean? Well, it means that the hazards have appropriate controls in place. Again, we come back to this word appropriate or sufficient. What does this actually mean? Well, now I'm going to explain a concept called the engineering hierarchy of controls. We're going to clearly define what we mean by an appropriate control. What is a sufficient level of control? So, we're going to talk about all the different controls that we can have in place going from eliminating a hazard, substituting, isolating to administrative controls to simply PPE. We're going to talk about them in terms of their effectiveness and then what is a sufficient control to have in place.

So the first level of control we can have is an elimination control. An elimination control is the it's the best. It means we're physically removing the hazard. It means the hazard no longer exists. We've removed the hazard completely. And these sorts of controls are best or easiest to put in place during the planning and design phase of the project where we have most control over the sequencing and the specific task we need to complete. An example of this say we got some works at height. We could say fitting off an antenna on a structure. If there was a way we could fit off the antenna at ground level and then simply erect the structure, then we we've eliminated the need to work at height. The next type of control we can have is a substitution control. So this is where the hazard still exists to some degree, but we've substituted it with a safer option. For example, excavating around services. We could substitute mechanical excavation with an excavator with vacuum excavation with a non-destructive digging truck. The next is an isolation control. So an isolation control is where we physically isolate people from the hazard. For example, if we've got people that need to walk along a road to get to a construction site and there's a risk that they get hit by a car, we could physically isolate them from the hazard by putting in place concrete barriers that protect them. Then we have an engineering control. So an engineering control is where we put in place a system to engineer out the risk. For example, for working at heights, we could put in scaffolding. So that would be an engineered solution to minimize the risk of somebody falling off an exposed edge. Then we've got an administrative control. So this is where we put in place a rule or tell people that they aren't allowed to do something dangerous. For example, we put in place cones along a road and we say people aren't allowed to step across this line to eliminate the risk of interacting or getting hit by a car. And then we've got PPE, so personal protective equipment, which is the lowest level of control we can have in our hierarchy of controls. And it's simply wearing protective equipment like helmets, gloves, high viz, and glasses. And it's the least effective form of control.

Okay. So we can clearly define what is a sufficient level of control based on this hierarchy of controls. any activity where we're exposed to a hazard, we need to have as a minimum an engineering control. We can't have an administrative control and a PPE to eliminate the hazard. So, we can't say that example of people having to walk along a road to get to the construction site. It's not sufficient to simply say you're not allowed to walk within 2 m of the road. You have to put in some sort of barricading to isolate or engineer out the hazard. For example, working at heights, if you have an exposed edge, you can't simply tell people you're not allowed to walk up to the edge. You need to put in place some sort of scaffolding that eliminates and or engineers out the hazard. So, as a bare minimum, what is safe enough? Well, safe enough means we've put in as a minimum an engineering control. So this could be guards on a machine. It could be ventilation in confined spaces. Or it could be edge protection when working at height. Simply putting in PPE or administrative controls is not sufficient. So saying you can't go next to an exposed edge or wearing a helmet will protect you from a dropped object. It's simply insufficient and it's not considered safe.

Okay. So now I'm going to talk about what tools we have available to manage safety on a construction site. Okay. So the first tool we've got available is a safe work method statement or a SWIMS. So a SWIMS is a document used to identify and control all of the hazards. So we walk through a construction activity, look at all the steps in the process and against each of these steps we identify the hazards and the control we're going to put in place.

Okay. So as an example, we've got a safe work method statement. So safe work method statement is a table like the one on screen and it's going to list out what are the tasks involved, what are the hazards associated with the task and then what are the control measures we're putting in place and importantly who is responsible for putting in place the control measures. So if you look at an example an activity like roof tiling the hazard is slipping or falling from the roof the control measure will be scaffolding. Then we specifically document how the control measure will be implemented. So scaffolding guard rail and access to the roof and then who is responsible for it the roof tiling supervisor.

Okay. So the next tool we have available a safety in design workshop. So safety in design is a series of workshops held during the planning and design phase of a project where different team members throughout the entire life cycle of the project. So during construction, commissioning, operations and maintenance all come together and we run these workshops to identify all of the potential hazards across the different phases of the life cycle. These comments are recorded in a register called the safety and design register. And these comments need to be closed out during the design phase. So all of these potential hazards need to be addressed. Now safety and design is so effective because of an underlying principle. Principle is that the earlier on you identify and control a hazard, the more effective it is to implement the control. So during the concept and the design phase, if we identify hazard, we can design out the hazard. We can completely eliminate it. If we identify during the procurement phase, we can make some changes, but we've lost some abilities to influence the design. If we only identify the hazard during construction, we're limited in what we can do. So the earlier we identify hazards, the more control, the more options, the better options we have to control them.

Okay. So let's look at a safety in design example. So we've got a hazard that's been identified which is working at heights which is roof access for services during maintenance. There's no existing controls in place. The phase of the project is the operations phase. And then we also put in the likelihood and consequences and the control method. So a control method is to include safe maintenance access points and facilities for harnesses in the design. And then we've got our control the level of risk after the control is put in place. We do this all the potential hazards identified during the safety and design.

Next option we have available is competency and training. So we can train the people completing the task of the skills and capabilities to complete them safely. So there's two parts of this. There's verifying competencies. For example, if we're getting someone to do electrical work, we need to check they're an electrician. The other way we can do this is we can actually train people and equip them with the skills to complete the task safely. For example, we can do a site induction so the workers are aware of the specific hazards to our site.

Now I've stressed the importance of safety as an ethical responsibility. I want to highlight another important consideration that safety is a legislative requirement. It's an ethical responsibility, but it's also a legal responsibility. It's a criminal offense to have people working in unsafe conditions. As a construction manager, you can go to jail if you don't properly manage and control safety on projects. And ultimately, one of the most important things with safety is to develop a culture of awareness to make sure safety is at the forefront of everybody's mind, that we're regularly discussing it in pre-arts, toolbox, and site inspections, and people feel they have the authority and capability to stop work if they feel unsafe.

Okay. So what are the key takeaways? Well, safety is an ethical responsibility. It's not a bureaucratic activity. It's an ethical responsibility we have to make sure the people doing the work can go home safely. We can't do something safely. We don't do it at all. What is safe enough? Well, safe enough means that based on our hierarchy of controls, we have as a minimum an engineering control in place for any hazards. And there's a variety of tools we've discussed available to us including safe work method statements, safety and design toolbox talks to ensure these controllers are in place and we can fulfill our ethical responsibilities.

In this video, we're going to go through a case study of effective project risk management. Often the best way to learn is through examples. We're going to cover everything we've spoken about so far in this section. We're going to go through and we're going to apply it to a wind farm. Okay. So, the project we're working on is the construction of a new wind farm. It's in a coastal area with high wind potential and the objective of the project is to generate electricity and connect to the local power grid. Okay.

So, let's recap our risk management process and how we going to control the uncertainty that matters on our project. Need to establish the context. We need to identify the risks and the opportunities. We need to analyze these risks. We need to evaluate them and then we need to treat them. Okay. So step one, we need to establish the context. So the over so we've got an overview of the project. The construction of a wind farm in a remote coastal area to generate renewable energy. Goal of the project is the timely installation and activation of turbines to meet energy production targets and capitalize on favorable weather conditions. Stakeholders. We've got we've got the project owner, the contractor, logistics providers, local authorities and environmental agencies and the constraints. So we've got challenges include complex logistical issues, weather variability and environmental compliance. Okay. So as part of properly establishing a context, we need to go through and determine the impact and likelihood of different risks and categorize them into low, medium and high.

Next step is we need to identify our risk. So we can do this through stakeholder engagement. So conduct interviews with key project workers, stakeholders such as the logistics providers and the regulatory authorities, host risk workshops and then review our existing documentation such as the EPC contract, the project specifications, the grid connection requirements and any specific environmental approvals. Okay. So the risks we've identified weather interruptions, so high winds can cause disruptions to things like crane lifts. We've got supply chain delays, so delays in having the turbines delivered. Transportation challenges, so difficulties in moving the oversized turbines to site, technical failures, so risk of malfunction and underperformance of the turbines, and environmental compliance, so challenges in adhering to wildlife and environmental regulation.

Okay. So now we're going to analyze and focus on one specific risk, the transportation challenges. So delays or issues to transporting the large turbines to site challenge on any wind farm because of how big the turbines are. And it's such a challenge to an extent that you have to upgrade roads often to the likelihood this is high due to the remote location and the complexity of the route. The impact could significantly disrupt the critical path task like delivering the turbines at site and we're rating the risk as critical. So it's highly likely to happen and it has a huge impact if it does happen.

Okay. So now we need to evaluate the risk. So we assess each risk based on the impact the schedule, budget, stakeholder expectations and safety. And we want to prioritize the key most important risks. So these ones we've identified are transportation challenges, weather interruptions and supply chain delays. These are our critical risks that we need to focus on and that we need to do something to address.

Okay. So for the transportation challenges, what are we going to do about? Okay, so we need to get root planning and permanent approval. So we create this as a project task and we allocate that responsibility to someone. We should engage specialist transport providers. We want to engage a company that has done this exact type of work before and can coach us through the entire process. We want to set up a local staging area to make the trip as easy as possible. We want to consider weather when we're doing this. So all of these possible risk response responses are risk and opportunity treatments we need to treat as project tasks. We need to make them the responsibility of somebody to implement.

Once we've decided to implement these specific risk response strategies, we then need to monitor how effectively we're managing the project risk. So, we're going to use real-time tracking. We're going to use GPS and regular check-ins on each of our deliveries to make sure that they're progressing as planned. We're going to have regular risk review meetings, so once a week, once a month. We're going to have a workshop to re-evaluate the risks and we'll determine how effective our response strategies are. and we're going to maintain our contingency and adjust it as we proceed through the project. So in summary, we worked through a simple case study of a wind farm construction project to look at the types of

risks and what we could do about it. As you can see, proactive planning is a form of effective risk management.

If we put in the upfront effort to think about everything can go wrong, what is the uncertainty that matters? What can we do about it? and then treat the risk management as project task as specific activities allocated to someone. We put them into place and we focus on what we can control. We'll do a lot to deal with the inherent uncertainty of any project.

Here's the complete guide to construction quality and completions management. We're going to talk about everything from inspections and test plans, punch list and close out. and we're going to give you strategies that are simple, effective, and you can apply to any type of construction project.

Let's be honest, quality isn't the most exciting part of a project. I've heard people say they love estimating, scheduling, but I'm yet to hear someone who says they're obsessed with quality. Quality is all about discipline. It's about dotting your eyes and crossing your tees. In an industry where profit margins are typically around 7 to 10%, considering that the average project spends around 5 to 10% of the project budget on defects and rework, it is an essential part of construction project management. Quality management is an optional. It's the difference between making money and losing money on a project.

So, in this video, we're going to be covering why quality and completions matters, why it's essential to any type of project. What is quality and completions? Construction quality management system, inspections and test plans, non-conformances, punch lists and defects, and effective completions management before finishing off with talking about some of the biggest mistakes people make in running a quality management system.

So before we dive into talking about how to manage quality, let's answer an important question. Why should we care? Why does quality matter? and more specifically, how does it help construction companies make money?

Well, the first point I want to make is quality is your ticket to play. It's not optional. It's mandated by law and it's specified in contracts. As an example, in most countries, you can't get a certificate of occupancy for a building unless certain checks and inspections have been completed. That's quality. If you don't show compliance building code, you can't hand over your project. You can't get paid. And this applies in all industries, not just residential or commercial construction. Try connecting a solar fund to the grid and see how much paperwork you have to fill out.

On top of that, it's almost always specified in construction contracts. In most construction contracts, there are certain quality assurance requirements that the contractor has to meet. If the contractor is not meeting them, they're in default of the contract. Your client can effectively stop paying you or show that you've breached the contract and terminate the contract. Take for example the Australian industry standard form of contract AS-4100. It mandates that contractors need to maintain and update quality assurance system. Clients have the right to audit the system and also perform their own independent checks of the work being completed. And if they can prove the contractor is not complying, they can backcharge them. And it can even become a form of contract default. If you can't prove that what you're building complies with the project requirements, clients can and will stop paying you.

On top of that, more and more clients are expecting contractors to hold certain licenses and accreditations like ISO 901, the quality assurance system. To get certified and maintain the certification, your systems must be documented, audited regularly, and followed. So quality is your ticket to plate. As a contractor working for construction companies, you need to be able to manage quality as a baseline for your job to continue delivering projects. The real question then becomes, should you just do the bare minimum or is there benefit in going above and beyond?

So next I want to give you some reasons why you should maintain not only the barebones quality assurance system you need to meet the contract requirements to continue getting and delivering projects but why you should go above and beyond and treat quality as importantly as any other discipline in the project.

So reason number one is your clients will notice. A clear professional quality management system will build your reputation fast. Studies have found that one of the core things clients look at and judge the reputation of a contractor is how professional their quality management system is and how effectively they help them to close out the project and hand it over. Basically, if you make life easy for your clients, they'll want you to come back and do more projects for them. It's an easy and simple way to differentiate yourself as a contractor in a highly commoditized industry.

Reason number two is commercial protection. So quality assurance records are more than just paperwork. They're evidence. I've seen this time and time again on project. Recently, we were installing specialist electrical equipment. We had strong quality assurance records. And when certain bits of equipment started to fail, we could very easily prove that we had installed them correctly. It wasn't an installation issue. It was a supply issue and we could claim the warranty. Detailed quality assurance records become proof of who did what, when, and where. And these will save you money in the long run.

The third big reason quality can save you money is that it prevents delays between trades. Through your quality assurance system, you can check the work has been completed correctly and fully and will prevent delays between subsequent trades. For example, if you've got a civil team installing pits and then an electrical team coming in after, if the pits aren't labeled, the electrical team don't know where they go. They're going to get much worse productivities. But if you've got to check within the civil installation that all the pits are labeled correctly, they've all been checked, they're all roped and mandled, you're not going to get delays when the electricians come to site. QA checkpoints allow you to have fixed handovers between trades that prevent you bringing electricians, other trades to site and causing delays.

Reason number four, and the big one, is just avoiding defects and rework. As I've mentioned before, defects and rework typically cost between 5 to 10% of a project's value. I can't count the number of times I've seen simple things like pre- poor inspections save tens of thousands of dollars. Just think QA as mistake prevention.

Reason number five is closing out the project faster. Projects always fail during completions and close out. No matter how effectively construction was managed, the schedule was adhered to. It's so common to see teams spend just as long finishing the last 5% of the project as they did doing 95% of the work. Why does this happen? Well, I call it kicking the can down the road. Get all these little jobs piling up, all these tiny little tasks that were too hard to do during the main construction. Maybe you needed special materials. Maybe you needed labels to get reprinted. Everyone gets demobed and then suddenly you end up with this 5% of the work that's the most challenging tedious little tasks. They all pile up and they end up taking months and months more than anyone could have ever expected. A proactive quality assurance system where you're proactively identifying and closing out defects as you do the work will save you so much time during the last 5% of the work.

So in summary, while most contractors treat quality assurance as a box ticking exercise, it can and will save you money if you implement an effective quality assurance system. Smart contractors use quality to prevent mistakes, protect their business, impress their clients, and finish projects faster.

So next up, I want to talk about some core principles of construction quality and completion strategy. I want to define the core terms you need to understand. These concepts are just going to help you understand the broad picture of quality management completions and how it relates to the objectives of the project.

The first one I want to talk about are requirements. So what is a requirement? It's just what we're getting paid to deliver. What our clients, what our stakeholders actually want us to build. So there's two core types of requirements. And understanding these is going to help you understand the overall terminology around a quality management and quality assurance system. So the first one are product requirements. These are the physical deliverables that the client wants us to build. They want a threelane bridge with guardrails, lighting, landscaping, so on so forth. This is the finished construction project. The deliverables.

Second type of requirements we have on project are process requirements. So these are non-product deliverables, things we have to do, but they're not part of the finished construction project. For example, certain requirements about how the work has to be done. For example, we might only be allowed to work during certain hours. There might be quality assurance requirements we have to meet. We might have to provide evidence of how things have been built. We might have to give them concrete testing. We might have to give them like certain electrical testings and signoffs. There might be completions requirements. So things we have to hand over at the end of the job to help the client with handing over to their maintenance team. So we might have to do a training session. We might have to hand over spare parts. So we've got the product requirements, what we're physically building. Then we've got the process requirements. So things outside of the finished product, but we still have to do them as part of our contract.

Okay. So where do requirements come from? Well, basically requirements come from contracts. We sign a contract to deliver a project. Attached to this will be supporting documentation that defines what we have to deliver. So we can have drawings and design documents attached to that. We can have project specifications, contract clauses, code and statutory obligations, standards, international standards or we might have third party or client standards.

So why do requirements matter in the context of quality? Well, requirements define the baseline against which we measure quality. Effectively, we're being paid to build something. What we're being paid to build is defined by the requirements. Therefore, the requirements define the baseline against which we measure quality. The purpose of quality is to measure we've delivered the project in accordance with the requirements.

Okay. This then helps us to actually define what quality is. So, what is quality management? It's the system to verify and validate that the constructed product meets the original requirements. For example, the design drawings show us that we have to build a 3 m by 2 m tall concrete footing using 32MPA concrete. The quality system is then going to verify that we're using 32MPPA concrete, that we including test results to show that it's measured strength, that there's been a survey check to correct check it's in the correct position, that there's been a pre-pour inspection. Then the quality of strong documentations is the documented proof that what we've built matches the requirements.

Now I'm going to introduce you to another incredibly important concept when talking about quality incomp completions and this is systems engineering. So systems engineering is a model that illustrates how requirements are defined and validated throughout the life cycle of a project. So this is comes from software engineering commissioning a broad different range of types of projects but the principle is very similar. You start with a project definition phase where you go from requirements. You progressively elaborate these through establishing the requirements, defining them better, producing a concept design, checking this concept design meets the objectives of the project, doing the detailed design, getting to an IFC stage, then constructing this design, and then we go through a series of testing and integration to always verify and validate that these requirements have been met. So you start on the left side starts with general project goals. They progressively turn into design specifications. And on the right side of the V, you can see that as we move from something being built, we're testing and commissioning to check these requirements have been met. The systems engineering model is the easiest way to think about how design quality and completions all relate. I'm going to talk about this a little bit more, but it's basically this understanding that a requirement gets turned into a design, gets constructed, then goes through a series of testing. Basically, that we prove that the original requirement has been built in accordance with the original requirements.

Now, this relates to the next important point, which is the relationship between quality and design. Design is the process where we define the technical solution that meets the requirements. Quality management is then ensuring that what we have constructed conforms to the design. Now this is a very construction specific definition of quality and design. For example in software other types of projects they speak about quality more holistically but in other words when we're talking about construction project the design is telling us what we need to build. Then quality is really ensuring that what we have built complies with the design. That's why design development is a critical part of overall project quality management and is essential to a proper functioning quality assurance system.

Okay. So building on this definition we come to construction quality assurance. So our definition of quality assurance and a quality assurance system on construction project in construction quality assurance we focus on compliance with the design documentation the drawings and specifications. Well holistic project quality management focuses on this entire systems engineering v which includes defining the original requirements turning these into an IFC set of drawings. When we talk about construction quality management, we're talking just about this. We're talking about compliance with the design documentation. So, while quality theoretically covers the overall process, when we're talking about construction quality management and a construction quality management system, we're talking about inspections, materials testing, conformance checklists, and basically everything that we do to verify that what we've built matches the drawings. The essential point here is we're not checking the drawings are correct.

Okay. The next concept, this is a term you've probably heard about and it's opening a bit of account when we're speaking about it, but commissioning. Commissioning something that applies more to mechanical, electrical, process systems, but basically commissioning is this part of the V. It's how we prove that what we've built meets the original requirements as opposed to just testing something meets the design. So, for example, we install an electrical cable. As part of our construction quality assurance checks, we'll check that the cable's correct, that it's labeled, that it hasn't been damaged during installation, but we're not checking is the cable the right size. Is it is it measuring the correct voltage? Commissioning system will actually check that stuff. So, you're checking that the load on the cable is correct, that the actual because you're also validating that the cable's been designed correctly. Commissioning moves through a series of stages where you test higher level and higher level requirements to effectively you're checking the overall system functions correctly.

Okay, what is completions? Well, completions is us wrapping up the project. If you remember, we had two different types of requirements. We had our product requirements which were the physical things we're building. That's what the construction quality assurance system checks checks that we're building things correctly. Completions is about ensuring all our process requirements have been met. Have we done completed all our quality assurance? Have we packed it all together? Have we done our owner training? Have we got our spare parts? Completions is really about how we document, wrap up the project, and then submit it back to our client. It's the entire process of doing our final quality assurance close out, getting our asbuilt drawings, our operations manual, training handovers, all our statutory signoffs, and filling out all our client documentation. If we talk about the differences between quality and completions, quality ensures that the work is correct and compliant. Completions ensures that everything is delivered and documented so the project can be closed off.

In this video, I want to give you the ultimate guide to construction quality management. If you're getting confused by all the different terms like inspection and test plan, inspection and test check sheet, punch list, defect list, category A defect, all these different terminologies. Don't worry, in this video, I'm going to spill out exactly what a construction quality management system does from start to end to achieve the project objectives. By the end of this video, you're going to understand the role of all these different components of a quality management system and importantly, how to set up and manage a construction quality management system on your project. Implementing formal quality management systems has been proven by studies time and time again to lead to more successful project outcomes. So, if you're wondering if there's something you can do to improve your job performance, accelerate your career, the mastering construction quality management is without a doubt should be the top of that list. Everybody talks about quality management. It's so important. It does this, it does that, it does whatever. However, people in my experience, in my experience in industry, tend to miss the point. That's why I wanted to make this video and I wanted to step through what are the components of quality management system, how do you use them, how do they relate to project success and how do you set up and manage one. So that's what I really want to break down as simple as possible. So in this video I'll go through what is a quality assurance and quality management system. The difference between project quality assurance and construction quality assurance, the link between design and quality. what commissioning is and how it falls into the overall system, the components of quality management system, and then finally, the biggest mistake I see people making time and time again when they're managing construction quality.

To understand what a construction quality assurance system is, we really have to think about the life cycle of a construction project. It starts with a set of drawings and specifications. We build the project according to these drawings and specifications. Then we create a finished product. The role of the quality assurance system on the construction project is to ensure that the finished product, what we built, complies with the drawings and specifications. So the construction quality assurance system is what relates the finished product to the original drawings and specifications. It's the processes we follow to ensure that what we've built matches what we intended to.

There's a very important distinction between project quality management and construction quality management. So project quality management is about ensuring the project meets the original requirement. So it's about the original requirements and ensuring what we've built matches it. Construction quality insurance is about checking what we built matches the drawings and specifications. So these might sound exactly the same to you. However, there is an important difference. The difference is the construction quality assurance system assumes that the drawings and specifications capture the project requirements. So then it's about ensuring that what we build complies with the drawings and specification. Construction quality assurance is a subset of project quality assurance because project quality assurance also has to check that the drawings and specifications cover all of the project requirements. That checking that the drawings and specifications capture the project requirements isn't a part of construction quality assurance. Construction quality assurance is simply checking and verifying that the drawing and specifications match the finished product.

Now this process of transferring the stakeholder requirements into a set of drawings and specifications is design development. So design transfers all the different stakeholder project requirements and turns them into a set of issue for construction drawings that the construction team then take and then build according to these plans. For example, a stakeholder requirement might be we want a 10-story building or we want the building to have an external facade that looks like this or the building code requires us to have two fire extinguishers on every floor. So these are the stakeholder requirements that get integrated into the drawings and specifications. The assumption behind construction quality assurance system is that the design captures the stakeholder requirements and somebody's checked the design to ensure that what's captured on the drawings meets the original project requirements. And therefore, the role of the construction quality assurance is simply to check that what we're building matches the drawings and specifications. And I understand if anyone's worked on projects that involve both design and construction, this is never true. design always has mistakes. It always has issues and errors. However, that's not the purpose of the construction quality assurance system. Purpose of the construction quality assurance system is simply to check that what we're building matches the drawings and specifications. Checking that the design correctly captures all the stakeholder requirements falls under design quality management.

So the design quality process is there to ensure the design fills stakeholder requirements. We can break this down into three subprocesses. First one is quality assurance during the design phase. So while we're preparing the drawings and specifications, we're checking are they correct? Do they meet all of the requirements? Once our stakeholders satisfied with them, we've checked them. they get an issue for construction drawing set which means as the constructor we can then begin constructing of the drawings. This moves into the construction phase which is all about identification of errors and issues during the construction phase through the RFI process where if we want to change the drawings or we identify any issues with the drawings, things that don't work during construction, we go through a formal change control process. Now I call this an RFI, a request for information. Other people call them TQ technical queries. They all mean the same thing. that checking with the designers during the construction phase if we want to make changes. The final part of the design quality assurance process is the commissioning process. Now, if you've heard the term commissioning, you might tend to think of it as something different. However, when you look fundamentally at what commissioning is, it's checking that what we've built functions as per the original requirement. So, it's going a step beyond checking that it functions as per the design. It's about checking that what we've built functions as per the intended requirement. So commissioning is also an important part of the design quality management process.

So now I'm going to go into a little bit more detail breaking down these three subprocesses of design quality management. And I know they don't directly form part of the construction quality management process. However, understanding how we check that the design meets stakeholder requirements is an important part that will feed into the construction quality management process. The first one is quality assurance during the design development process, which is the process we follow to ensure the drawings and specifications are correct. When we say correct, we really mean three different things. First one is that they capture and fulfill the stakeholder quote. So they produced a technical solution that fulfills the intended stakeholder requirements. Second one is they're free from errors that they're actually correct. And the final part of this is that they're constructible. So within the realms of what's possible in terms of the construction that we can actually build what the drawing say to do the design core process has to check these three things. Then it's check stakeholder requirements. they're free from errors and that we can actually build it. The tools that are used to ensure this is done correctly would be regular and independent checks of the design and validation of the original project requirements against the design.

Once we move into the construction phase, the drawings get an issue for construction stamp which means they're ready to be built. We then go have a design management process during the construction phase. So this is the process to ensure we manage changes to the design during construction and this will ensure the design remains correct. So any times the drawings are changed it needs to get approved by the design team. Once the design team check that the change is okay that it's technically feasible that it still complies with the project requirements. The change gets approved and reissued to the construction team and then they're able to build this. So the tools we use to do this would be RFI. So this is a request before the fact to change the design. NCRs where we have some sort of error or issue during construction and when we're not able to build what the drawing specified. And then the final type would be a direction from the design team to change the design that's not prompted through construction. So for whatever reason the client has required additional scope, they've required something additional added to the design, the designers will integrate this into the drawings and issue a design change notice.

And so the final part of our design quality management system and it's not strictly a part of design management. However, it's useful to think of it as part of the same process is where we take what's finally been built and rather than checking this just complies with the drawings, we actually check it complies with the requirements. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what's been built functions as per the original requirement. So, this is the role of the commissioning process where we're checking that what

What they look like. The next thing we need to understand is how to write an inspection and test plan as a construction project. Engineer or manager, you're certainly going to have to produce some of these. So, it's important to understand how to actually write one.

The steps in writing an inspection and test plan will be: number one, to review the drawings and specifications of the scope you're writing the ITP for. Develop the construction methodology. So, understand the steps in the process of building one. List out all of these steps. Identify which detail and information does the drawing show for each of these steps and understand what can go wrong. If you understand what can go wrong, you understand what needs to be checked to ensure it's done correctly. Fill out all the relevant supporting information. So, the relevant drawing and specifications, the frequency, these sorts of things, and then submit it to the client for approval and get them to provide some feedback and comments.

So ultimately, when you're preparing an inspection and test plan, what you really want to be documenting are the checks we do around the things that can go wrong. That's the ultimate goal of why we're preparing the document. We want to create a big list of everything that could possibly go wrong for that specific construction activity and then check that we're not going to make those mistakes.

So, for example, with concrete works, we could incorrectly get the survey set out. So, we might the surveyor might be working off the wrong set of drawings, or the drawings might have a wrong height on them. Could use the wrong concrete material. We might procure a type of concrete that's not applicable to that scope. We could use the wrong placement method. There might be some standard where we can't allow concrete to drop more than 2 m. It might not be compacted or vibrated properly and get air pockets. We could use the wrong type of formwork, or the formwork might not be correctly braced so the concrete collapses. We could have the reinforcement move during the pour so we no longer get the correct cover on the reinforcement. We might miss installing casting items. Maybe there's a service penetration because we haven't checked those are installed before we poured the concrete. We missed doing them, or we missed installing casting items like bolts.

When you think about it, for any construction activity, there's a lot of things that can be done incorrectly. So, our job when we're writing the ITP is to come up with a list of all the things we need to check to ensure that we're not going to be making these mistakes. Each of these mistakes we could possibly make are going to relate to a step in the construction process. So the basis of our ITP is all the steps in the process we follow to deliver the works.

Now, regardless of the specific construction activity, there's some broad steps that any construction works we're going to follow. So, these I like to think of as pre-works. The stuff we do before we start the construction activity, the actual construction activity, and then the close-out activity. So the pre-works will be things like design. So checking the drawings and specifications correctly. If we're procuring materials from a supplier, they might have given us shop drawings. We might need our designers to approve these shop drawings. So they're all the design activities. We'll need to buy materials. So, basically, we want to check we bought the correct materials and they match the specifications. And we also had any handover from previous trades. So, for example, if we're installing underground electrical cables and a civil contractor has put in the conduits, has the civil contractor checked that all the conduits are free from debris and they've been roped correctly? So they're all the handover activities.

Then we move into the construction. So, this is really step by step the construction activities involved in that task and checking against each of those what could go wrong. And then the close-out activities. So, any final testing we do. For example, for concrete, we might get concrete testing done, documentation of any as-built drawings or changes to design, and then hand over to subsequent trades or final acceptance by the client. So those are the steps we want to document for every single activity.

Next to each of the steps in the construction work, we document the relevant specifications. So, for each of these steps, there'll be a specification that governs whether it's done correctly. So these specifications might be from project specifications, notes on drawings, or relevant standards. For example, if we're installing concrete reinforcement, there'll be a specification that says the cover we're allowed on the reinforcement, and then that's what we need to check. So we're allowed 50 mm of cover in the specifications. We check that we've got 50 mm of cover. We're allowed 100 mm. We check we've got 100 mm.

So, once we've documented the steps in the construction work, the relevant governing specification, the next thing we need to document is the test method. So, what is the test or check we're doing to ensure the works are done correctly? So, these could be specific to a discipline. So, be concrete testing or compaction testing for earthworks, or they could be generic. So, visual inspections, recording photos, or getting material dockets.

Next, we need to define the timing and the frequency of these checks. So, how often will this testing be undertaken? So, it could be time-based. We might do the checks every day or every week, or it could be activity-based. More common for construction works, there'll be activity-based checks. For example, every lot of earthwork. So, if we're installing underground conduits, it could be every 20 m of trenching. Or we might do it per concrete pour. So, every concrete pour, we'll do a pre-pour inspection. We'll do an inspection while they're placing the concrete, and then we'll do a series of post-pour checks. So, more likely your timing and frequency is going to be activity-based.

And then we need to define our acceptance criteria. So, what is the standard the testing has to be? For example, for our concrete testing, it might need to achieve a strength of 32 MPa within 28 days. For our, if we have installed an electrical cable and we're doing an insulation resistance test, might need to achieve greater than 50 megaohms when we do the test. So, these could be test results, they could be subjective verification by an expert. They could be records like photos, or they could be certain desirable criteria. Really depends on the specific check we're doing or the specific test as to the acceptance criteria.

The final thing for each of these different steps in the construction process, we need to define who is responsible for approving it. So, these could be internal to our company, or these could be external experts we engage, or it could even be the client who has to check. So, it might be subcontractors doing it for us. It might be an engineer or a project engineer, could be a supervisor, could be the client or their owner's engineer, or it could be another relevant stakeholder. So, it's important to define for that specific activity who is responsible for checking and approving the checks.

Now, when we're defining who is responsible, we also define what level of oversight they give the step. So, there's three different types of responsibility. Could be a hold point where works cannot proceed past this point until that person's approved it. So, for example, on a concrete pour, for a pre-pour inspection, it might be a hold point for the client's structural engineer. So, the client might need to go out, inspect the reinforcement before they give approval to pour concrete. It could be a witness point where they just have to be told about it, but they don't necessarily need to inspect it. Or it could be a review point where they review it after the fact. So, it really depends on defining what level of inspection the responsible party needs to undertake.

Okay. To make this all a bit more realistic, let's go through and do an example of a conduit installation or a technique. So, if you don't know what conduit installation is, it's installation of underground pipes that people use to install and pull electrical cables through. So, it involves trenching, laying the conduit, and then backfilling and compacting. So, we're going to go through and do an example inspection test plan of conduit installation. So, you can see people practically what's involved in an ITP.

Okay, let's start with what would be the input to this document. So, we've got the design, the drawings and specifications that show where the trench is going and the details of the trench. So, I've got a simplified example here that shows a cross-sectional view of the trench which shows the conduits in orange. There's three 100 mm electrical conduits. They've got 600 mm cover and there's bedding sand around the conduits. And then we also need to install a marker tape which shows where the conduits are. The methodology is they're going to excavate. They're going to lay the conduit and then backfill. There's specifications around the materials we're allowed to use. We need to have an excavation permit in place before we do any works. And we need to do compaction testing and mandrel testing. So, mandrel testing is when you pull a sort of like a plastic ball through the conduits to ensure they're clear of debris and that there's space in them to pull cables through. So, we need to do compaction testing and mandrel testing.

Okay, let's start with our table from our ITP. So, this is the structure we're going to have to populate. We're going to have our pre-work. So, these will be checking the drawings are correct, ordering the materials, our construction works which will involve those steps I went through, excavating, installing the conduit, to backfilling, and then any close-out activities. So, now we go through and populate this table with every step in the process and then all the other relevant information against each of these steps.

So, for the design check, we've got the issue for construction drawing set. We need to check that this is prior to performing works and the acceptance criteria is before starting works we have an issue for construction set of drawings and approved RFIs. Requirements around the procurement of materials. So, we need to procure the conduit. The conduits we procure have to comply with AS3000, the design requirements, and the project specifications. We're going to check this each delivery and the acceptance criteria is we're going to collect every single delivery docket we get conduits and attach these to our ITP and the site engineer is responsible for this.

Then we've got our construction activity. So, the trench excavation will be the activity is excavating the trench to the correct design depths. The relevant specifications and we're going to every 20 m we're going to check this is done prior to conduit installation and we're going to get the surveyor to check the depth of the trench against finished service level. So, every 20 m the surveyor is going to check that the depth is correct against the finished service level. So, as you can see, relevant specifications, the testing we're doing, how frequently we're doing the testing, what the acceptance criteria is, and who's responsible for the checks.

But yeah, so once we've written our ITP and prepared it, who has to approve it? So, internally, the project quality team or any managers we have would typically approve it. Then we need to send it externally to the client to approve. This is critically important because we want the client to review how we've written the ITP and make sure they're happy with the checks we're doing because at the end of the day, at the end of the job, we're going to submit all the ITPS for them with their acceptance and that's how we're going to prove to them we've correctly delivered the project. So, it's important that they are allowed to make any comments, that they're happy with the level of testing we're doing, that they believe it also complies with the standards, but it's going to make closing out the job at the end of the project a million times easier. And then once we move into construction, all we have to do is complete the ITPs as we're completing the construction works. Simple as that. The effort we put into managing process is in correctly writing the ITPs, documenting all the checks correctly, and then all we're doing as we move into construction is going through step by step, ticking off doing all the checks, getting all our delivery dockets, organizing all our testing, getting photos and records. It's easy as that. Then when we're done at the end of the job, we submit them to our client and we can prove we've correctly completed the works. We're going to minimize the number of defects we have. Any defects we do get, we'll easily be able to address and we'll have records of where those defects started.

In this video, I want to teach you how you can become a better construction project manager by more effectively managing non-conformances. Non-conformances can increase project costs by 10% and delay the schedule by around 7% based on a study by the Construction Industry Institute. So, in an industry with razor-thin profit margins, non-conformances are a good place to put your time and attention and focus on effectively managing them to ensure your projects are a success.

Okay, so in this video, we're going to be covering what a non-conformance report is, the difference between a non-conformance and a defect, the components of an NCR, how to prepare an NCR, and then finally go through an example NCR.

Okay, so an NCR is a formal document used to identify, track, and resolve instances where a project does not conform to specified standards, requirements, or plans. So, we've already defined a defect as any failure to meet the project requirements. An NCR is just a significant defect. So, if a defect is significant to the operation of the plant, to the functioning of what we're building, or even commercially significant, so if it's a large dollar value item, we would turn that into a non-conformance report. So, a defect is any failure to meet the project requirements. And defects can be both minor and major. Minor defects might be something like missing labeling or electrical cabling. While a major defect could be an incorrect cable installed that needs to be cut out and replaced and it has a significant cost and prevents operation of the plant. So, it's significant also to the operation. NCRs are a formal process we go through to capture significant defects. Depends a bit on the company and project specifics of how they choose to manage them. However, NCRs have the characteristic that they're significant.

So, going into more detail on this, you should raise an NCR when a defect is commercially significant. So, it could have implications with the contract we have with our clients or the contract we have with our subcontractors. It's going to take some time to fix or it's going to have a significant cost. Additionally, we should raise a defect when we want to proceed with some sort of investigation, root cause analysis to work out why this defect has come up, or we should raise an NCR when we want to change the project standard. So, because of we can't put over raising close-out a defect the normal ways by just rectifying it to meet the original standard. If we want to raise an RFI to the design, change the original standards, then we should also create an NCR.

NCRs have several different components. So, first off, we'll need to identify and define the NCR. So, talk about what the scope is and what happened. We then need to analyze the root cause. So, work out what happened and what the underlying cause of the defect was. We'll need to work out how we're going to resolve the defect, and then we'll need to work out how we're going to prevent the same thing happening again.

So, first off, when we identify an NCR, so NCRs like defects will be identified during inspection and testing. So, as we go through and complete our ITPs, if there's any failures to meet the project specifications that will create a defect, the significant defects become NCRs. Or we could identify them through an audit. So, we might go out and do systematic audits and checks of processes or products. And we could also identify in sales like this. They can be identified by a client, by the contractor, or by subcontractors. So, really anybody involved with or working on the project can identify NCRs.

So, the next component of the NCR is the analysis. We need to analyze what happened, why it happened, and what we can do to fix it. So, we identify the cause of the NCR. We identify who's responsible. Now, this is important commercially. Correct. Identifying the responsibility of rectifying the defect, 'cause remember we said NCRs with significant defects. So, the significant cost and time associated with them. So, appropriately identifying who is commercially responsible for fixing it is important. And we also want to identify why did the NCR happen. Could it was it due to incorrect design drawings? Was it due to incorrect procurement of materials? Or was it due to incorrect workmanship?

We then need to come up with a resolution for the NCR. So, there's a couple of different things we could do, and depending on what we choose to do about the NCR will require different approvals from different parties. The first one, easiest way to fix it would be to rework the defect to meet the original standard. We simply redo the activity to meet the original project specification. The second thing we could do is we could accept the defect as it is without repair, or we could repair it with concession. So, we could repair it to meet a new different standard. These are different because number one, reworking to meet the original standard, we would need no change to the project requirements, which means we need no approval from the design or no approval from the client because all we're doing at our own cost, we're fixing the defect to meet the original project specifications. Options two or three, where we accept the defect as it is or we repair it to meet a new standard, will require some level of rework to meet a new standard. In that case, we need to get approval from the client and approval from the designers to change the project specifications to ensure they're happy with it and to ensure they accept it.

Okay, let's wrap up with going through an example of a non-conformance report. So, this is the type of form you'd fill out when raising an NCR. We'll go through the different structure of the form and talk about the specific example NCR we're talking about. So, this NCR was part of an imaginary project called the Western Road Project and it occurred on 27th of May, 2021. So, at the top, we're just filling out the details of the NCR, the facts, what happened, the relevant documents, all these sorts of things. So, the NCR name was "Underbore Missing Tracer Wire" and the engineer responsible, the work package was the combined services trench, so installation of underground conduits, and the subcontractor was Under Boring Solutions. The design package and reference. So, the drawings that documented the work that was being undertaken and any relevant standards and specifications. There's a relevant quality lot. So, what quality lot was the work being undertaken under? And then there's a description of the NCR. So, let's look at the description. So, the standard design details for the underbore as detailed in the drawing show 300 mm electrical conduits and one 100 mm communications conduit. Additionally, a 5 mm steel tracer wire was meant to be installed as part of the bore. However, Under Boring Solutions, the contractor drilled the bore, pulled through the electrical conduits. However, they failed to install the tracer wire. The bore was sealed. They finished the work and only after did they realize the tracer wire was missing. We've also got it as a product NCR. So, you can have a product NCR or a process NCR. Product NCR is a failure to meet specifications relating to the product we're delivering. Process NCR is a failure to follow process. So, this is related to the product. So, the product is the finished underbore. The design showed steel tracer wire and we failed to install this. So, what are we proposing to do about it? So, we're proposing to repair with concession. So, we're not reworking to meet the original standard. We're reworking to meet a new standard and so this is something that would have to get approved by our client and the design team. So, we're asking to install a 5 mm tracer wire within one of the spare 100 mm conduit. So, the original design showed that the steel tracer wire was installed separately to the conduits. However, we're asking to install it within the electrical conduits and we're giving an explanation for why this is okay to do and how we're going to install labeling as well to show why it's been done like this. We've got a cause of the NCR which was "People." The subcontractor failed to review the drawings properly and the contributing cause was the contractor did not properly understand the design. The process improvements is that we're going to update our inspection and test plans to ensure that future underbores we have a representative from our own team on site checking that this is done correctly. So, we've got corrective action, what we're proposing to do about the defect. We've got gone through the cause, the contributing causes, and how we're going to improve processes in the future. We then take this NCR. We then submit it to the design team and the client to get their approval to ensure they're happy with doing it. Once they're happy with the proposed corrective actions, we then go out physically do the works, close it off, and then we could successfully close the NCR. So, through this process, you can see how we've encountered an issue with the installation and we're going through a process to resolve this to ensure ultimately our client is happy with the product we're producing.

This video is going to be all about how to more effectively manage construction project defects. The goal of this video is to teach you about the defect management process on construction projects so you can reduce the number of defects on your projects and significantly reduce the overall cost and the time it takes for you to deliver the project. According to research by the Construction Industry Institute, rework due to defects can cost between 4 to 6% of the total project budget. That's why in this video, we'll define defects, or talk about what they are. We'll talk about why they matter, why they're critical to manage as part of achieving project success, talk about the different types of defects, and then talk about the process to manage, eliminate, and reduce construction project defects.

So, starting off with the definition, put simply, a defect is any failure to meet specified requirements and standards for the project. A defect is as simple as that. It's any failure to meet the specified standards or requirements. So, some examples of typical defects on construction projects. On a road project, we might have poor line marking. On electrical cables, we could have missing labels. In a concrete structure, we could have cracking. In the basement of a building, we could have water ingress. Or on structural steel, we could have missing torque marks on the bolt. So, these are just all small, typical examples of the types of defects you come across on different construction projects. So, all of these different items have the same characteristic. They're a failure to meet specified standards of the project. So, we go out, we deliver a construction project. As part of the quality management process, we're checking and verifying that what we're delivering meets the standards. That a defect is any failure to meet these specified standards. The ultimate goal of a quality management system is to eliminate defects, to have zero defects, to hand over a finished project that complies with all the specifications and standards, and there's no deviations from these requirements.

So, why do defects matter so much on construction projects? Well, to answer this question, you need to understand the 80/20 rule. If you've ever worked on a construction project, you'll find that managing the works, 80% of the works take 20% of the effort, and then the final 20% takes 80% of the effort. There is always a ton of small items at the end of the project that just consume so much time, attention, and resources to close out. And closing these out successfully is critical to getting paid on time, to finishing the project successfully, handing over to our client. And time and time again, you see construction projects fail, even though for the majority of the work, they've been delivered successfully. However, through the closeout phase, there's all these legacy defects that quickly chew through the project's profit margin.

Extending on this, we can categorize the reasons defects matter. And I'm going to explore each of these in more detail: down to safety, value delivered, the customer and stakeholder satisfaction, contracts, cost, and time.

So, the first reason managing defects is critical to managing construction projects successfully comes down to safety. The origination of any design requirements or specifications that go into the project documents often come from safety standards. For example, the strength of concrete on a bridge is critical to holding up all the cars, traffic that will go across it. If we don't meet those concrete strength requirements, we can't prove that the bridge is actually safe for all those different people to use. If we think of another example, insulation on electrical cables. If we don't have proper insulation on our cables, we could have an electrical fault that could start a fire. So, ultimately, through the quality management process, we ensure that what we deliver complies with the specifications and standards, which directly ensures that what we're building is safe for people to operate and to use. A real-world example of this was the Surfside condominium collapse in Florida and the US. So, failed waterproofing on the construction of a 12-story building led to corrosion in the steel reinforcement, with the structure ultimately collapsed and killed 98 people. So, you can see deviations from the original standard, which was waterproofing of the concrete, led to a legacy issue that caused corrosion to steel reinforcement and ultimately the integrity of the structure of the building, leading to a collapse that killed 98 people. So, when we're talking about defects, we're not just talking about money. We're also talking about an ethical responsibility to ensure that what we're building is safe for use.

The next reason defects matter is that the elimination of defects directly leads to additional customer value. Let's think about this. The project specifications and standards document what we're getting paid to build. Ultimately, each of these standards, each of these specifications directly relates to the value we're creating for the customer. So, if we have defects in the product we're producing, we're ultimately producing something that isn't as valuable. So, eliminating defects ultimately increases the amount of value delivered by the project.

This then relates to my next point, which is the less defects we have, the more stakeholder satisfaction we have. So, defects will ultimately impact the perception of the project by the client. So, even if they're aesthetic and minor defects, we could build something that's perfectly fit for use, perfectly safe to use. However, if it's got a whole lot of cracking in the concrete, scratches on the walls, ultimately the way our client sees it, the way our client perceives it is that we ultimately haven't delivered something valuable, they've got a poor quality product. So, they go to satisfaction and defects are also directly related.

Next, defects have important commercial implications. So, when we're talking about the contractor building the project and they're ultimately responsible for delivering the project in line with the requirements and specifications, this requires them to produce product that is free of defects because ultimately they're getting paid to deliver what the project specifications and requirements say they need to do. So, ultimately, there's significant contractual implications through contracts. Defects can impact payment and they can also impact contract completion. So, getting your security back, closing out the project at the end of the job. You see this a lot typically around payment on construction projects. So, payment is always an issue on construction projects. Cash flow is the lifeblood of the construction industry and payment is a powerful motivator. So, regularly on projects, you see contractors make payment claims and principals reject the claims not because they haven't necessarily done the work, but because they haven't done the work to the required standards and they can't prove that they have done so. The principal is meant to pay the contractor based on the value of work they've completed, and often there's a dispute around valuing this work based on what both parties see as outstanding work or outstanding defect. So, defects will always relate to payment on construction projects.

This then directly leads on to the next issue which is cost. So, rework ultimately costs money. Cheapest way to deliver a project is to do it once. Do it right the first time, not to come back and do the same task again because you messed it up the first time. So, the less defects we have, the less money we're going to spend. Defects can consist of both incomplete work, so work we didn't do the first time because we didn't have the materials, because we didn't have the access for whatever reason, but also defects can consist of rework where we haven't done the work correctly, so we're coming back and doing it again.

Finally, defects matter because they impact the duration of the project. So, quickest way to deliver a project in the same way that the cheapest way to deliver a project is to do everything correctly and completely the first time. If we have defects, if we have incomplete work, if we're coming back and doing things twice, it's going to suck up our resources and it's going to push out the duration of the schedule. So, the quickest way to complete a project is to do it without defects, without rework.

Okay, let's now talk about all the different categories of defects. So, what are all of the different types of defects that exist on construction projects? So, the first one, we can categorize defects based on their cause. Whether they're caused by incorrect design, incorrect construction methodology, the wrong materials being used, missing equipment, these sorts of things. So, defects can be broken down based on their cause. We can break down defects based on their significance. So, are they aesthetic only? Is it paint markings on a wall, or is it a significant defect that impacts the operation of the asset? Is it a missing electrical switchboard? So, we can break them down based on the significance. We can also break them down based on who's responsible. Is it the responsibility of a subcontractor who's done something wrong? Is it because it's an incorrect design? Is it the responsibility of the designers to fix and get an answer to? Then finally, we can break them down by the type. Are they due to incomplete work, which we're waiting on materials to do, or is it because of an incorrect installation? So, some of these are some of the different ways we can categorize and break down defects on a project.

So, how do we manage defects? We know defects are a problem. We know they cause significant harm to a project success. What can we do to manage them more effectively? Well, the quality management process ultimately exists to eliminate defects. So, through the quality management process, we're directly addressing the presence of defects on a project. Our goal is to deliver a product that fulfills the project requirements. So, the quality management process is there to identify and then close out and ultimately try to eliminate defects. So, let's look at the quality management process and where defects are addressed and managed through this process. So, it starts off with as inputs to the quality management process, we get the project requirements, the design drawings, and any contract requirements. We then develop a quality lot structure. So, this will be a list of all the work we have to do on the project. The same as a work breakdown structure. And against each of the individual construction requirements, we develop inspection and test plans. So, an inspection and test plan is a document we use to check and verify that the work has been done correctly. Once we've developed our inspection and test plans, we'll go out and we'll complete the construction works. Against each of the activities, we do our inspection testing. Where we fail inspection and testing, we record that as a defect, a non-conformance, a failure to meet the project specifications. These go into our punch list. We then work through our punch list, closing out all of the individual defects. And then when we've successfully completed the inspection and testing for some work, we've closed out the defects relevant, we can successfully close out project work for that portion of the project. So, that's the quality management system. We use to ensure we're identifying defects, recording them, and closing them out, and then handing over a product that's free from defects.

What's involved in completing and handing over a construction project so you finish successfully, make your client happy, and get paid on time? In this video, I'm going to explore the completions management process on construction projects. A study by KPMG found that 69% of construction projects fail to be completed on time, often caused by defects and rework. So, project completions management is a critical part of construction project management and understanding the completions management process is going to help you more successfully deliver projects and accelerate and grow your career in construction project management.

So, in this video, I want to talk about what is project completions, why it matters, the difference between quality management and completions management, the different types of project completions, the requirements to complete a construction project, and some tips on how to achieve project completions on time.

So, what is project completions? Well, throughout the course of a construction project, we take a set of drawings and specifications. We build the project according with these drawings and specifications and then we come to the end of the project. What we need to do here is we need to take the finished product we've built. We need to hand it over to our client. So, we need to get them to accept it. We need to finish the project and we need to hand it over successfully to our client and finish our responsibilities. The client ultimately wants to make sure they're getting what they paid for and they want to make sure there's a smooth transition to the next phase of the asset's life cycle, which is the operation, maintenance, and usage phase of the asset. So, the project completions management process is how we, as the builder, as the contractor, we facilitate this process for them.

So, project completions, if we want to give it a more professional, concrete definition. So, project completions is the process through which deliverables are finished, inspected, and handed over to the client, ensuring the project meets the contract requirements and quality standards.

So, now that we understand what completions is, the next question I want to answer is why does completions matter? So, the first reason completions matter is cost. Poorly managed project completions leads to increased defects and reworks for us, the contractor, to incur. An extended allocation of project resources to closing out the project. So, these are things like management staff and supervisors that need to stay on the project for an extended period of time. And the final one is we'll incur liquidated damages and contractual penalties if we fail to hand the project over on time to our client. So, a client will hit us with contractual penalties, which will also hurt the project's bottom line.

The second reason project completions matter is because of contract. So, directly related to cost is contracts. So, there's contractual requirements around project completions. Contracts will specify a certain date we need to finish the project, the practical completion date of the project, and the completions management process is there to ensure we finish the project on time. We're contractually obliged to meet these dates. And as I just said before, when I was talking about costs, if we fail to meet these dates, our client is justified in hitting us with liquidated damages and delayed penalty costs.

The reasons completions matter is it matters to the client. So, the on-time completion as per the requirements is one of the key metrics the client will look at in terms of justifying project success. The client wants to be able to use the asset by the date in the contract. So, incomplete project work will also damage our reputation in the eyes of the client and it will damage the perceived value of the project.

So, now that we understand why project completions is critically important to the client in terms of securing new work, the cost of the project, and we're contractually obliged to ensure we achieve it. And now I want to talk about the relationship between project completions and project quality management because quite often I see people blur the two into one broader topic. However, quality management and completions management are related but different. So, project quality management, as we know, is the verification and validation that what we built matches project requirements. Completions requires that the quality activities have been completed correctly. That's the core requirement of project completion. So, project completion is to hand over the project successfully. We need to have completed all the quality activities. So, we need to have checked that everything we've built matches with the project requirements and we can provide evidence of this to our clients.

So, now we understand why completions matter and how it fits into project quality management. Let's talk about the different types of project completion. There are several different types and definitions of project completions that exist, and they vary depending on the degree of outstanding works and how the finished asset is accepted for use. So, what are the different types of project completion? Well, the first one we've got is substantial completion. So, substantial completion is where we get operational use of the asset and the client can use whatever we've built, except for some minor aesthetic defects. Second type is final completion. So, final completion is where the project is fully complete with no punch list and we've accepted and can take final payment from the client. Third type is conditional completion. So, this is where completion occurs under certain conditions. For example, if it's a building, we might get a temporary certificate of occupancy contingent on us fixing some important outstanding works, or we might get partial completion where certain parts of the asset get accepted and finished for use. However, we still need to finish other parts. So, the piece of infrastructure we've developed is partially usable.

So, now that we understand what completions is, the different types of ways we can achieve project completion, let's talk about what's required for project completions. What do we need to do to successfully hand over the project to the client? And we'll talk about the sources of these requirements and the types of different requirements. What are the different completions requirements? Well, the first one is dependent on the contract model. There might be a contract model where we're designing, building something, and maintaining it for 2 years. So, then our completions requirements come in after 2 years of maintenance. It will depend on the project specific. So, the type and nature of the project. If we're building a power plant, our completions requirements will depend on being able to export electricity. If we're building a train station, it will depend on opening that train station to the public. It will depend on specific client requirements. So, this client might have specific requirements or systems that we need to use to achieve completions. For example, they might have an asset management system. And as part of our project completions, we need to upload all the different assets we built for the system. Then finally, there'll be internal processes that govern completions requirements. For example, to close off a project, our company might require that the electrical license holder has done an inspection of the project and is happy with it. So, these are all the different sources of completions requirements.

Now, let's look at what are the deliverables we need to complete to hand over a finished product. And to me, this is the crux of where the topic is. So, I'm going to go through all of these different ones and look at what specific requirements exist around achieving. The first one is construction complete. So, this is the physical completion of the construction works and making the asset ready to use. So, if we're talking about a building, that will come down to a certificate of occupancy. Talking about a solar farm, this will be exporting power to the grid. As part of finishing the construction works, we also need to complete our quality assurance. So, these are the checks and verifications we make to make sure what we've built is correct. So, that's how we prove that we have in fact finished the construction works. This will come down to inspection and testing, documentation, recording everything, getting our client to sign off any hold or witness points, and compiling and submitting all of this documentation. We'll also need to complete handover walkthroughs. So, these are joint inspections with the client to show them what we've built and get them to sign off and accept that they're happy with it. These walkthroughs, we give the client an opportunity to inspect the works and raise any defects that they've picked up so we can add them to our punch list. And as I was saying when I spoke about handover walkthroughs in project quality management, that design issues often arise. So, it's important to have a member of the design team present on these walkthroughs.

Commissioning is also an important part of project completions, depending on the nature of the project. Now, for a bridge project, you're not going to have a commissioning process. However, for any mechanical or electrical projects, you'll commissioning will be a large part of the project. So, this will be function testing the installed systems to ensure they operate as per project requirements. Commissioning will contribute to the punch list. So, any defects picked up through the commissioning process will also need to be closed out. And there may be some witness testing. So, some testing that the client needs to witness.

We also need to close out all of our defects. So, these will be identified during a quality management process, commissioning, or handover walkthroughs. We need to close out all the different punch list activities so that a client accepts to finish work and any outstanding minor cosmetic defects we might be able to close out after practical completion. But that would require acceptance from the client.

To get completions, we'll also need to prepare and submit our as-built drawings to the client. So, these are the set of drawings and specifications we maintain during construction. We documented any changes on. We send these back to the design team. They'll draft a new revision of the as-built drawing set, which we'll also need to submit to our client. In certain circumstances, depending on the completion requirements, but I've seen it on quite a few projects, clients will want an asset register. So, they'll want a list of everything we've installed, documented, and recorded so we can submit to them showing serial numbers, manufacturing, lead time, supplier, contacts, all these sorts of things. We may also need to hand over spare parts. So, say we've procured a certain type of light fitting. We've ordered 100 of these light fittings. The contract may specify we need to hand over 5% of the installed spare parts. So, we'd have to hand over five light fittings. And this just helps the client when they're going into maintenance that if they have a fault, that they've got spares available to change them out.

In addition to spare parts to replace, the client may also require us to provide any special tools or maintenance equipment to run the asset. And we may also need to prepare and submit an operations maintenance manual. So, this would be detailed maintenance instructions for how to run the asset, how to manage whatever we've built. So, this will document things like the frequency, the need to perform inspections, the different types of inspections and tests, corrective and preventative maintenance, how to do fault finding, or certain supplier contacts. So, this is basically a big document that shows clients how to run the asset, how to maintain it, and how to use it. Documents all the supplier contacts and basically just makes the way for them to go from the construction phase to the operations maintenance phase much easier and smoother.

In addition to the operations and maintenance manual, they might also want us to conduct a series of training sessions. So, these will be training sessions to familiarize the operations and maintenance team, the usage team with the plant. So, we'll have to show them how to use it, how to operate it, the different types of faults. We might have to give them a list of logins and passwords, if we've created any software that they'll have to use. Basically, just all these sorts of types of things. So, it's really again about making the process for the client from moving to the construction phase, the operations and maintenance phase as easy, simple, straightforward as possible.

Depending on the contract requirements, we might have maintenance or a defect liability period we need to work through. So, this is where us as the contractor, for a certain period of time, are responsible for providing continued maintenance and defects rectification. This might be a 2-year period where we need to come to site and come back to rectify any defects or faults arising from the construction activities. And while this won't impact our initial project completion, at the expiration of the maintenance period, we'll need to perform another completions process to show that we've completed this maintenance correctly. So, again, this will depend heavily on the specific requirements in the contract. Depending on the specific project requirements, there could be a whole range of other completions requirements like sustainability requirements, Green Star requirements. We need might be some building or plant tuning.

where we're helping with figuring the commissioning and the operations to maximize the plant output. You might have to give them certain permits, licenses, certificates of occupation or hand over a pack of the different warranty information for all the different spots. Any of these things will depend highly on the project specifics.

But as you can see, all this documentation is there to make the transition from the construction phase to the operations and maintenance phase as easy as possible. To manage completions effectively, we need to submit everything to complete the job. So that's why the completions management process is all about identifying everything we need to submit and starting working on it as early as possible to hand it over on time.

So my tips to make sure you hand over your construction project on time is to treat completions as an individual function, an individual set of activities and document these in the project schedule. Document all of these completions requirements where they're going to be reported on and where people are going to see them and they're going to see if they're slipping. Document these requirements early and make every effort to submit them progressively. It's the only way you're going to hand over your project on time is to start thinking about completions in the planning phase. Document all the requirements and work through the process methodically. The same as any other function, the same as any other task on the project.

So, we've pretty comprehensively covered quality and completion systems and how they work. Now, let's talk about where things tend to go wrong. How do mistakes within the system cause issues with time, money, and credibility?

By far the biggest mistake I see is people underestimating the importance of document control. A manager once said to me, "Document controller is the most important person on the project." It's always stuck with me and increasingly as I progress in my career, I see more and more how true this comment was. The amount of avoidable mistakes and chaos I've seen from people building off the wrong sets of drawings, avoidable reworks, cost blowouts, hours lost chasing missing test reports, construction projects delayed from missing drawings, incorrectly sent RFIs. All these issues just cause absolute nightmares and chaos on projects. Construction projects generate hundreds if not thousands of documents. And if you need a system to manage and check their correct and maintain version control cuz if you don't, it will cause you absolute nightmares.

The second mistake I see all the time is people over complicating a quality assurance system. Every project you go on has someone who says, "We do things differently here. We're using this special fancy system," but all they're really doing is reinventing terminology and over complicating something that's really not that hard. Quality assurance system is really about defining what testing we're going to do, doing the testing, and submitting it at the end. Doesn't need to be any more complicated than that. You don't need to come up with your whole range of different terminology and words. All we're really doing is checking things against requirements in a systematic way. It's not rocket science. So, always try to keep it simple.

The third mistake I see a lot is that people just let quality assurance get out of hand. Quality assurance systems don't fail overnight with some dramatic failure. What happens is they tend to slip a little bit each day when people are busy and before you know it, you miss one inspection. You skip a few photos. You forget to file a checklist. And then suddenly, you're writing NCRs because you haven't followed the process. You're searching, spending hours searching for missing test reports. Your client's not paying you or withholding payment because you can't submit a check. Your management's getting cross at you and you're burning days in admin and stress. The lesson is just to stay on top of it. Make it a regular practice. Quality assurance is all about discipline, not scrambling.

Next big mistake I see is people ignoring requirements. Now this is very much to do with commissioning, but people not to tend to think about handing over the project till the end of the project. But often getting all these requirements together takes a lot of time. For example, spare parts. You have to order the spare parts. They have lead time. You need to organize vendor training. All these different requirements tend to take a lot of time to get together. And people don't think about them until the very end of the project. And suddenly they're waiting months to provide the final documentation. And if you don't track these from the very start of the project, you'll never hand over on time. So the fix is to define the deliverables, the requirements your completions system has to achieve. Assign responsibilities early and then simply follow these up regularly. Set it up at the start, monitor it and control it and you'll finish on time.

The next mistake is people goldplating the QA system. People get excited when they write ITPs. They want to make everything perfect. They say, "Oh, we're going to take a photo of the trench every 20 meters showing the depth at the bottom, the width, blah blah blah blah blah." All of a sudden, sounds great in practice. Then all of a sudden, you're in the field and you've got to take 2,000 photos of trenches. You've got to file them to store them. And because you've written it in the ITP, the client signed off on it, you've said you're going to do it, it's effectively now requirement of the project, it just ends up wasting no time, and you get nothing for it. It doesn't actually improve the quality objectives of the project. Doesn't do anything to improve the output. So the main takeaway is only track what matters. Keep things as simple as possible. Focus on the core objectives of the quality management system producing evidence you can apply preventing mistakes. Keep it as simple as possible. Don't get over excited and it will be much easier for you to stay on top of it.

The next mistake I see when it comes to quality, and it relates to what I was saying about the snowball effect and letting things get out of hand, is people skipping the process. Cutting corners feels efficient in the moment, but it will always come back to bite you later. You install something before sign off. Tweak the design but skip the RFI. You borrow a certification from another job. Something will come up. Something will come back to bite you and it will be 10 to 100 more times work to fix than the work you avoided by cutting the corners. In my experience, shortcuts always lead to future problems.

The next big mistake I see that happens during the tender phase is not defining quality assurance and completions requirements in contract which basically will lead to scope growth. So having to do testing or completions things that we didn't allow for in the budget or estimate or getting into disputes about client of what we have to do to hand over the project. Quality assurance, completions, buying spare parts, doing additional testing all costs money and takes time. So it needs to be defined during the tender stage like any other project task. Most quality assurance issues aren't technical. They're management mistakes. Keep it simple. Start early. Stay on top of it. And don't leave all the paperwork till the end. Quality assurance is about discipline, not being smart, creative, or doing things over the top. It's about staying on top of it, dotting your i's, and crossing your t's.

What gets measured gets managed, but in construction, it's only half the story. Projects generate mountains of data and information. Invoices, schedules, site diaries. But even with all this information, teams still often miss early warning signs. Project controls isn't about analyzing data. It's about analyzing the right data, the right way to communicate a message and get a result that improves the profitability of the project. In this complete course on construction project controls, we're going to teach you how to track progress against the budget and schedule. Use simple tools like earned value management, spot cost overruns before they snowball, use project controls to influence project teams and decision makers, and apply these skills to real projects with step-by-step examples.

So, I first want to start with the all-important question of why do project controls matter? And guess what? Here's the honest truth. You can deliver a project profitably without ever knowing your budget. You don't actually need to track costs to finish a project under budget. Controls don't build projects. Controls don't pour concrete or install underground services. They don't fix quality problems. All they do is measure and report. So why bother in the first place? Well, there's a famous quote that says, "What gets measured gets managed." When people know costs are tracked line by line, they think twice about waste. When progress is being measured objectively and you don't need to front up to management next week to explain why your task is behind and what you're going to do about it, you treat things differently. Objective tracking forces accountability. So the real reason project controls matter is because they change behavior. They shift the mindset of the project from focusing on getting it done to getting it done under budget and ahead of schedule.

The thing is, bad news isn't always a problem. Bad news delivered late is a problem. Without controls, you only know you've overspent when you can't do anything about it. With controls, you can spot a cost or schedule blowout when you've only done 5 to 10% of the work. Without it, you only know when you've hit your budget. Project controls give you the power to see problems before they arise, change behavior, and do something about it. They focus attention on busy projects. Managers drown in paperwork and data. Through project controls, we distill these raw data into useful insights that people can act on. We know we're behind, we're burning cash too fast, or we need to resequence the works. We take the data and the project controls process tells us what we need to do. Good project controls directs attention to the right problem at the right time. On top of that, project controls supports claims and disputes. When variations happen, project controls provide evidence of what's happened and what the true impact is. They turn "he said, she said" situations into "here's the data."

So what if we don't use controls? What happens? Well, we do extra work without ever knowing. We waste money we don't have. Plans become meaningless. And surprises become claims and disputes. And there's a ton of evidence to back this up. Multiple studies have proven beyond a doubt that better project controls lead to better project outcomes. So why do controls matter? Well, fundamentally, project controls change the way people behave. They make you proactive not reactive and they protect your profit, your time and your reputation.

Let's move on to talking about what actually is project controls. So, project controls, to best understand the definition, we first need to talk about the two stages of a project. Any project can really be broken down into two main stages: the planning phase and the execution phase. Planning is where we decide what we're going to do, how to do it, how much it's going to cost, and when it's going to be done. Execution is actually doing the work. Planning is characterized by assumptions, estimates, and guesswork. No plan ever exactly matches reality. When the execution phase of the project is the reality, it's what actually happens. The best and most useful way to think about project controls, if particularly if you've done any sort of systems engineering, is the feedback loop between the planning and the execution. The goal of project controls is to ensure we follow the plan we agreed to. We measure what's actually happening, not what we thought would happen, what's actually happening. You know when and why you're drifting off the plan and you take action to correct course before it's too late. It's the feedback loop that links the planning phase with the execution phase. Without project controls, you have a plan and a project but no clear feedback loop between the two.

So if we want to give it a more specific proper definition, project controls is the system for planning, measuring, analyzing, and correcting project performance in terms of cost, time, and scope. Now, some people include quality, some people don't. But for simplicity and because I've spoken about quality in other courses, I'm just defining project controls as correcting and managing project performance in terms of cost, time, and scope. It answers: Are we doing what we plan to do? If not, how far off are we? And what can we do about it to get back on track? And fundamentally, I keep coming back to this point that project controls is all about changing behavior by enabling smarter decisions.

Okay, next up I'm going to fly through some core concepts around project controls. So, we said project controls was about scope, schedule, and cost. Well, scope control is about what's in and out of scope. Schedule control is about ensuring we finish on time. We stick to the original plan finish date. Cost control is about tracking how we're spending money against our budget. So, they're the three elements of the project we're controlling.

Now, in the planning phase, we determined what we were going to do, how much we're going to spend, and how long it was going to take. These plans are captured in documents referred to as baselines. These are the approved reference points for what we're going to deliver, how much we're going to spend, and how long we're going to take. The key baselines are the cost baselines, which is the total approved budget broken down by scope or cost code; the schedule baseline, which is the planned timeline showing when each activity would happen; and the scope baseline, which is the agreed deliverables and the work breakdown structure. Basically, the baselines are the benchmark. They're the ruler against which we're going to measure performance. Are we going over our baseline or are we not?

The core concept around baselines or the core tool we use to develop our baselines is the work breakdown structure. So, work breakdown structure is a deliverable-oriented breakdown of project scope into manageable chunks. It connects scope to cost to schedule. In an ideal world, it ensures you know what to track and where problems are happening. Basically, it's just breaking down the project scope into pieces. And the gold standard of project controls is having an integrated work breakdown structure. So, we break the project scope down into pieces and against each piece, we know what work we're doing, how long we have to do it, and how much it's going to cost.

If I show you an example of a work breakdown structure, let's imagine on a road project, we break it down into earthworks, structures, and bridges, utilities, and road works. That would be level one. Then we could have WBS level two where we take each of these core domains, we break them down further. So for earthworks, we break it down into scrub and clear, bulk earthworks, drainage, and subgrade. For our structures, we've got piling, columns, abutments, the deck slab. So basically, we're breaking down the project scope into smaller and smaller pieces. The fully decomposed project scope is referred to as the work breakdown dictionary, which is where we have all our individual work packages. Again, the gold standard is that we use the same, and this is surprisingly hard. It's much harder than you think it would actually be, but you have the same work breakdown structure for your scope, your schedule, and your cost. So, the same activity, you can look at how long you'll be able to see it in the schedule, how long's allowed for it, when's it planned to start and finish, and what our budget for it is. So, for example, we have a switchboard foundation. We've got the task which is the construction of the foundation for switchboard 112 including all earthworks and concrete. We have a budget of $25,000 and we have a duration of 3 weeks.

Okay. So the next all-important concept is after establishing our baselines, is measuring performance. That's the next core concept of project controls. The idea is that we measure what we're actually doing. How much work we said we were going to do is our baseline. How much work we're actually doing. We get through performance measurement. So there's different tools we can use to do this. We could use earned value management, which combines scope, cost, and schedule into clear performance metrics like CPI, cost performance index, and SPI, schedule performance index. Now we're going to talk about these in much more detail later on. And then we can also have progress measurement tools like rules of credit systems, quantity tracking, and site reports. So, for example, our plan might tell us for our trenching, we were meant to do 500 m over 2 weeks. We're tracking our progress. We might know that we've only done 100 m in week one. Clearly, we have a problem because we've done 20% of the work in 50% of the time.

Now, how can we track progress? Well, we've got production-based tasks. So, these are basically tasks that can be expressed in terms of a single core quantity. For example, trenching or cable installation where we can measure it based on how many meters we trench or how many meters of cable we can install. Then we have progress-based tasks. These are tasks that can't be expressed in terms of a single quantity. For example, procurement is a classic example of this where we're not going to measure procurement based on how many words of a scope of works we write out. No, we're going to measure it based on some sort of rules of credit system. Okay.

So, performance measurement is all about measuring what's actually happening. Forecasting is where we use the data from the present to predict what's likely to happen in the future with more accuracy than when we originally planned the project and established our baseline. So it's using today's performance to predict our final cost and completion dates. Forecasting basically gives us early warning signals of when we're going to blow our budget or delay our schedule. So for example, where we tracked we'd done 100 meters of trenching in one week, we can clearly see that we're not going to finish the trenching activity by week two unless we fundamentally change the way we're doing something.

Reporting is then the process where we turn this raw data into actionable reports. It's how we keep our stakeholders informed. It's how we get agreement on key issues. It's basically how we get agreement of what we're going to do about issues. For example, 100 meters in week one. We can express this as we're 20% complete when we should be 50% complete, which is giving us a forecast completion date of week five rather than week two. We put this in context. So we say that this is a critical path activity. It's if it's delayed, it's going to push out our overall completion date and we need to do something about it. Or maybe it's not a critical path activity. So we're happy to take longer than we originally planned and it's not a big deal.

A treatment is then when we decide to do something to correct performance. For example, with our issue with our trenching, we've identified a deviation and we need to come up with a solution to fix the problem. How can we fix our issue? We can add an additional crew, which will ensure we finish on time but increase our cost. We could change the finish date if it's not a critical path activity. Treatments typically require a trade-off. We either increase our cost to finish faster or reduce the cost but take more time. So treatments always have to be taken within context. And again, I'm going to explain all these more and what to do in specific situations later on.

Then finally, we've got change control, which is a system we use to manage scope changes and variations. So why it matters? It's basically going to help us prevent uncontrolled increases to the project scope, referred to as scope creep, without cost and time blowouts.

Okay. So in summary, the core concepts of project controls. Project controls keeps the plan and the execution of the project linked. It's our feedback loop to ensure that we stick to our original baseline and change things as required. The baseline defines the plan. The scope, schedule, and cost baseline defines what we said we were going to do at the start of the project. The work breakdown structure is the core way we do this by breaking down the project into component pieces. Performance measurement is how we measure what we're actually doing. Forecasting is how we predict the future. Reporting is how we express and explain this to management and key stakeholders. Treatments are what we do when we've got a deviation from the plan. And change control is how we manage uncontrolled changes to project scope. Mastering these building blocks and we'll develop a simple repeatable system to deliver projects with fewer surprises and more profit.

Next up, I want to talk about where project controls fits in amongst all the other domains of construction project management like estimating, scheduling, design management, and quality. It's really essential that you understand where project controls fits in because it's not a standalone function. It ties heavily into other domains like estimating, scheduling, design management, contract management, quality management, and procurement. So, we're going to go through each of these different knowledge areas, the main domains of project management. We're going to talk about exactly how project controls ties into these.

Okay. So, first up, we've got estimating. So estimating is building the cost plan, developing the budget. It is how we forecast what we're going to spend to deliver the project. So then the control side of it would be then tracking our actual expenditure against this budget, forecasting the final cost, and identifying cost overruns. So the key point here is estimating is the function that sets the budget. Project controls is how we check whether we're staying within it.

Okay. Similarly with scheduling, we've got the same relationship between the two of them. The schedule builds the plan of how we're going to deliver the project, when everything's going to happen, and then the project controls function is checking that we're following this plan and adjusting it as needed. So, it's tracking our actual progress versus our planned progress. Again, scheduling sets the timeline. Project controls checks that we're sticking to it.

Okay. The next one we've got is design management, which we could also think of as scope definition and control. The design defines what we're going to build. So, what we're going to build, the scope of the project, is going to drive the cost and the schedule. Fundamentally, what we're doing through project controls is we're monitoring whether both the actual design deliverables are on time and completed in accordance with the schedule, but then we're also tracking changes to the design. So changes to the scope and how they impact the cost and the schedule. The key thing we're trying to avoid here is scope creep. So scope creep is doing extra work without an adjustment to our schedule or budget. And design management is defining the scope in detail. Project controls ensures that we're managing changes to the design.

Okay. Next up, we've got contract management. So contract management sets the way you can think about contract management is it sets the legal and commercial boundaries of the framework. The contract tells us who's doing what and how much they're getting paid, how long they have to do it, under what terms. Project controls tracks whether contractors are delivering as per their contract, verifying progress claims, monitoring the contract cost and schedule impact. So again, very related when we're considering that the contract is the source of truth with defining what we have to do. Again, contracts ties very closely with design management and scope control. Project controls is monitoring the performance. So how we're performing against the contract requirements.

Okay. Next up, we've got quality management. So quality management is the process of how we verify and validate that we're building in accordance with the design and specification. So the work we're doing meets the agreed-upon standards, the inspection and testing process. Now, some people include quality control within the broader topic of project controls. I believe they are distinct and different topics where quality is about the physical inspection and testing, and the impact on project controls. It's going to track cost and time impacts, defects, rework. It's going to report whether our quality trends and how they're impacting project performance. For example, how much we're spending fixing defects. So quality management is about validating the deliverables. Project controls is going to assess the impact of the quality control activities on time and cost.

Okay. Next up, we've got risk management. So risk management is the process through which we plan for uncertainty and develop mitigation plans. It's really how we consider uncertainty in the planning and delivery of the project. Project controls is going to track how actual risks that eventuate or what we're spending to mitigate risks impacts our budget and schedule, and it's going to adjust. And we're also going to need to adjust our forecast based on emerging risks. So as we identify new risks, we have to hold specific contingency for them that's going to impact our forecast. So risk management is about looking ahead, trying to identify uncertainty, plan for it, and manage it. Project controls is about dealing with what's actually happening.

And the next one we've got is procurement management. So procurement is the process through which we acquire the external goods and services and subcontractors we need to deliver the project. And within the broader topic of procurement, we typically also talk about subcontract administration. So managing these vendors. Now considering around 70% of typical project costs, obviously it's going to vary hugely depending on the scope and type of project you're doing, is going to be sourced to external vendors. So a lot of the money we're spending, a lot of the actual duration to complete the project, the work that's being done is going to be done by external vendors. Subcontract administration, managing these vendors, ties very closely into the broader topic of project controls. So project controls is really going to be assessing and forecasting how effectively we're managing our external vendors, tracking the expenditure, the duration versus the budget, and then it's going to ensure timely completion of the work. So procurement is about buying the work. Project controls tracks if our vendors are delivering on time and on budget.

Okay. So the key point I wanted to make is in reality, there is huge overlap between all these topics. Scheduling control and project controls are effectively the same thing. Cost control, whether you say it fits under estimating and cost management or you say whether it fits into project controls, is really irrelevant. The idea is you really need an integrated approach to manage this. You need to understand how estimating relates to project controls. We're also going to use estimating in our forecasting of our cost to complete. How all these domains tie together, and whether you call it cost control, schedule control, or project controls, fundamentally what we're trying to do through project controls is link our plan to reality. Project controls is our feedback system to ensure that we're managing the work in accordance with the plan and if things are changing, we're dealing with them.

So now we understand broadly how project controls fits in with the other domains of construction project management. Let's move on to giving you a step-by-step framework to implement and administer project controls on a project.

So, the first step of project controls and the most overlooked one is feasibility. What is feasibility? Well, it's the tender team handing over the project to the delivery team and the delivery team saying they accept it. What it means by accepting it, it means they're saying they're willing to do it for that budget and that duration. So first step is the tender team give the project to the delivery team. The delivery team review the estimate, the schedule, and the scope and they say they're happy to do it for that price. If they can't, they need to come up with a plan of how they're going to recover the profit. At this stage, the contract's signed. It's awarded. There's no going back to the client and asking for extra money. It's a fixed lump sum contract. The delivery team need to review the estimate and the schedule and the scope. They need to understand exactly how to deliver the project and if they think there are shortfalls in the budget and the schedule, they need to come up with a plan of how to recover the cost.

Now, it's important point to note here is that not all projects are going to be able to do this. There are mistakes people make in estimates. People underquote jobs, but you shouldn't accept that from the outset. You should always have a profitability plan. So, the delivery team take ownership of the project. They do their own checks. They say we can do it at this cost and this budget. We're flagging a shortfall of 50 grand and we're going to recover that extra money through these planned variations or these value engineering opportunities. It's about basically them taking accountability for the project. They feasibility check the estimate and the schedule. They develop a winning price. They turn it into a workable delivery plan and give you a fighting chance of making money.

Now in parallel with this process, the teams need to develop their baselines. Now a baseline, it's important to point out that a baseline is different to the tendered deliverables. So a budget is not the same as an estimate. An estimate is a forecast cost to deliver the work. It's structured around how much it's structured around the calculation, filling out the client pricing schedule, presenting it to the client, working out how much your costs are going to be, and it's fundamentally used to win the job. It's presented as a calculation. Budget is how you track and allocate expenditure to manage your cost during the project. It's the approved baseline that you're going to use for cost control.

If you look at this diagram on the left, the total payment from the client is fixed. That's your revenue. That's the price we've agreed to the client. If we said we're going to do it for $10 million, that's how much they're going to pay us. Of this, there's margin. So, profit margin and corporate overheads. And then also cost baseline, our cost to do the work. Of these costs, we can break them out into direct and indirect. So, what we're actually going to spend as well as risk and opportunity. We then break out our direct and indirect into cost codes. Now, hopefully the budget that goes into a cost code is what we think we're going to need to spend to do the work. Hopefully, that's less than our actual direct and indirect cost from the estimate. And then within that, we would have procured scope. So, within procured, so say for example, we have a budget for procuring formwork. It's $20,000, but we get a quote from a supplier for $17,000 to buy all the formwork. That's the procured scope. So the estimate is the calculation of the cost to do the work. It's how we come up with our total payment from the client. Our budget is our controlled plan of how we're going to spend money. And the cost codes is the breakdown of the budget into all the buckets of how we're going to spend money. To give you an example, you might have a concrete structure in the estimate that's made up of plant, labor, materials, and subcontract costs. Within this, there's going to be an allocation for formwork. There's going to be an allocation for steel fixing. There's going to be an allocation for concrete pump and concrete placement. Your budget wouldn't have a cost code for materials for every single structure because you don't buy the materials per structure. You buy the materials for the site as needed. You might buy all the formwork at once. So you should have a sitewide material code, but you might have a labor-specific cost for that structure. So the point here is fundamentally how you spend and track money is different to how you calculate the costs of something.

Now similar to this is the tender schedule. So the schedule we developed during the tender will be different to the delivery schedule. So tender schedules are generally high-level. They show that you can meet the client deadlines. They're usually broad and optimistic. The delivery schedule will be developed post award during the feasibility stage by the delivery team. Needs to be more detailed showing your real resource needs. And the fundamental purpose of these two schedules are different. Tender schedule is to verify that we can meet the client dates and present them with a plan that shows we know what they're doing. Delivery schedule is a detailed plan of how we're going to do the work that's used for planning the project. Typically, you also remove contingencies. So, a net schedule would be the schedule, your plan of how you're actually doing the work. The wet schedule is the one the client sees that might have additional contingencies shown in it. The delivery schedule then becomes the schedule baseline for tracking time.

Now a critical point here is your budgets and your schedules should align. For example, if your budget for the formwork for structure has 600 man hours, your schedule should show something like six guys for 2 weeks which equates to around 600 man hours. So the two should align and again this is why you need a consistent work breakdown structure. You need the same cost codes as activities in your schedule and it will make tracking, managing, controlling the project a thousand times easier.

Okay. So once your baselines are established, you've done your feasibility, you've worked out your cost to deliver the project, you got your budget and your delivery schedule, you can develop your control system. So the control systems are these feedback loops that link the plan, the baselines to reality. So we need to work out and finalize how to track costs. We need everything broken into cost codes, buckets of money. And then against each of these cost codes, we want baseline quantities and units of measurement. For example, steel fixing, we might track per ton of steel. Earthworks, we might track per meter cubed. Again, we want the same thing for our schedule. Our baseline schedule, our activities, and baseline quantities and unit of measure. Again, ideally your schedule and your budget should be showing the same activities with the same units of measurement. It's going to make your life a lot easier. Then you want a way to measure performance. The key metrics, the reporting format that you're going to use to summarize and present this in. You want to have identified particularly with the schedule, the critical path, so the series of activities that if delayed will delay project completion and your risk and opportunity and contingency. And these are the things you're going to report against. Then you need to set up a system for recording data. So labor you might track with time sheets. Then you need a system for recording data. So this might be with time sheets that you're using to track labor hours against cost codes. You might have a daily site diary. You might do weekly progress work walks to inspect it. Basically you need some consistent and repeatable way to collect data from the field. And then all you're doing is comparing the data you're collecting to your baselines and addressing variances. Basically, you want a clear breakdown of the project scope that makes sense, realistic, and there's agreed measurement rules.

Now, fundamentally, how we put this into practice is going to vary slightly depending on whether it's subcontracted work or self-performed work. So, subcontracted work is where we engage an external vendor or supplier to do the work on our behalf. The key here is their taking on the cost and productivity risk. So, we engage someone on a lump sum to dig a 1,000 meter trench and they budgeted to do 20 m a day, but they're only doing 5 m a day. That's not our problem. They've signed a lump sum contract to do the work. Where it is our problem though is if in terms of the schedule performance, they're not meeting their schedule and we don't have any sort of recourse like liquidated damages. So, what are the subcontract management? It's really going to be how well you set up the subcontract and you align the objectives of the subcontract with the objectives of the project. Meaning that they've agreed to a finish date that matches your finish date or betters it and their budget or the cost what you have to pay them to do the work is less than your budget. So, when you subcontract, you're passing on the cost risk to the subcontractor and they're carrying the full financial exposure for doing the work. You still have to track their performance. You want to particularly track their schedule performance with subcontractors, requiring regular progress meetings, checking what they're claiming on their payment claims versus how much work they're actually doing. You then need to administer the contract. So, manage variations and changes to scope. That's how you primarily control your costs with a subcontractor by basically not paying them extra to do the same amount of work. Control their payments. You make sure you're only paying them for the work they're doing that they've completed correctly. And you're also analyzing their performance. Particularly with a schedule, you always want to be paying attention to how much work they're actually doing, the quantities they're giving you. Are they correct? Are they accurate? And the core, the fundamental principle with managing a subcontractor is to trust, but verify. Yes, you want to trust them, but you want to check everything they're doing as well.

Now, self-perform works where we're engaging our own laborers, plant, materials. We're taking on the production risk, full cost risk for the work. Obviously, we have to track it much more carefully. Primarily the way we do this is we need to track every dollar we're spending and compare it to how much work we're getting done. So we're tracking every labor hour we're spending, all the hire and idle time for the plant and equipment, what materials we're buying, what wastage we're getting. Basically, we're tracking every single dollar we're spending in a cost tracker and comparing it to how much work we're getting done. So, if our budget rolled up was $50 a meter per trenching and we're spending $75 a meter to do this to do our trenching, then we're obviously going to blow our budget. Again, we also want to be tracking our schedule performance, how much work we're getting done versus how much we plan. This stuff is super simple and straightforward, but it's about having a system where you're capturing all this information, then making the very simple comparison. So principle with self-perform is you need to measure and manage everything that's happening. When subcontracted, the cost risk and hopefully the time risk is also outsourced through a contract. So you're really just trusting them to do your work, but you're checking everything they're doing.

Now, so if you're tracking your cost, you're tracking your performance. Fundamental to this is measuring your quantities. So quantities are just an objective way of tracking how much work is getting done. Did we do 100 meters of trenching? Did we do 200 m? Did we do 100 m cubed of concrete? Or did we do 500 m cubed of concrete? It's just an objective way of measuring how much work is actually getting done versus what we plan. They provide an objective record for our cost, whether we got value for money from what we've spent, for our schedule. Are we physically meeting the planned output? For example, if we've spent 50% of our concrete budget but only poured 10% of the plan structures, then obviously we're going to blow our budget without having an objective way of tracking the quantity of work done. It fundamentally is subjective and it relies on guesswork. So it might not be accurate. Practically, how do you want to do this? At a regular period of time, a regular interval, you just want to do a physical count or check of how much work's been done. How many meters cubed of concrete we did? How many lineal meters of trenching? How many tons of steel did we install?

Now, not all tasks can be represented by a quantity. Particularly, these are non-physical tasks or tasks that involve a complex series of steps. For example, procurement. Procurement isn't a task we can measure with some single metric. It might be it might have defined stages. For example, for buying a building that's getting prefabricated, there might be a 12-week fabrication period, 2 weeks for FAT testing, 2 weeks for delivery. That 12-week fabrication period, we might break down into four milestones. And against all the milestones in the process, we put a percentage complete. And then we're just tracking are they meeting the milestones. But again, it's the same principle. We're just using a percentage here rather than a physical quantity to track it.

So we've measured our quantities. The next thing we need to do is we need to maintain our schedule. Now this is probably one of the biggest issues I see on projects regularly that a good schedule is developed during the planning phase. Yes, it has some issues but because it doesn't perfectly reflect reality, people just ignore it. No one continues to update it and it slowly becomes worse and worse and worse until what the schedule's showing doesn't reflect what's actually happening in the work. So the core principle here is at regular intervals you want to be giving feedback to the planner or updating it yourself and keeping the schedule rather than a static document that a live tool that's used to plan and manage the work. You want to be using actual start and finish dates, keeping percentage complete accurate, checking for impacts of the critical path, reevaluating the critical path, and using current data in the schedule to forecast the finish dates and adjusting the sequence if needed. The finish date, the actual finish date of the project should be the finish date in the schedule. And it's important to note why this is so important is that the schedule is a critical input to cost control. A large proportion of total project costs will be driven by the duration of the project. For example, staff salaries. If you've got a project manager, they're getting paid monthly. The project goes from 6 months to 9 months, then you're paying an extra 3 months of their salary. These indirect costs are going to form a significant portion of the overall project cost. So the only way you're going to accurately know how much it costs to finish the project is if you have an accurate schedule and you're accurately forecasting the duration of the works.

Okay. Next up with all this data we need to do something with it which is fundamentally where we're going to analyze and treat variances. All we're doing is we're collecting all this data. We've got our baselines. We compare what's actually happening to our baseline and then we analyze it and we need to do something about it. So fundamentally to analyze it, the core principle of how we do it, whether we use the entire system or just components of it, is using earned value management. So earned value management is really a fundamental project management concept where you compare cost and time. There are three core principles to it: there's our actual costs, which is how much we're actually spending; there's our planned value, which is how much we plan to spend at that point in time; and then there's our earned value. So earned value is the budgeted cost of work completed. Our planned value is how much we plan to spend up to that certain point of time. And our actual cost, as the name suggests, is how much we're actually spending. The comparisons that we do is we look at schedule variance, which is the difference between our planned value and our earned value. If we plan to have done more work than we have up to this certain period of time, then we're behind schedule. We also compare our actual cost with our earned value. What's the budgeted cost of the work we've completed? How much have we actually spent? If we spent more than the budget for doing that same amount of work, then we're over budget. Basically tells us where we have issues. Do we have issues with schedule performance or do we have issues with cost performance? We can then analyze this further and basically what we want to do is identify the root causes. Is it productivity issues? Are there a lot of quality defects? Are we wasting a lot of materials? Is our subcontractor performing badly? Are they overclaiming on variations?

Now, you always want to look to improve no matter what. Whether even if you're under budget, you can always do better, even if you're ahead of schedule. The principal way that we look to improve performance is by always asking ourselves the question, how can we do it faster and cheaper? There's 100 ways to build any same project. We want to come up with the best possible way to do it. We want to do it safely obviously, but we also want to come up with the fastest and cheapest way of doing that. The principle we use to do that is divergent thinking. So divergent thinking is understanding that there's 50 problems to a solution. We need to brainstorm what all those problems are, assess them, and then come up with the optimal way to do it.

If we are over budget or behind schedule, we need to apply treatment. So treatment is basically addressing a variance. Now whether it's subcontracted or self-performed, the level of control we have over the problem will be different. But the principles behind it will remain the same. Obviously, if we've signed a contract with a subcontractor and their practical completion date is behind the date that we need to finish the work, we're limited with what we can do. We've outsourced that to someone else and we've signed a bad contract. But again, the principles I'm going to talk about are the same. So, if a task

is behind schedule, the question is always, is it on the critical path or near the critical path? Is it part of the chain of events that if delayed delay project completion? If it is, we should spend more money or take on more risk to finish it faster.

The way we do this is with there's really two principles to doing this, which is crashing or fasttracking. So crashing is where we add additional resources, spend more money on it over time to get the work done faster, and it results in an increase in cost to complete the activity. Fast tracking as you can see in the diagram is where we overlap tasks. So say we had the original plan was we finish all the trenching before we start the conduit installation. Fast tracking is where we overlap the task. Now doesn't necessarily increase cost but it increases the risk of delays. Say the condute installation crew catches up to the trenching crew and then we have standown due to that. So that's increasing risk but it's not necessarily increasing cost.

If an activity has float, meaning it's not on the critical path, we don't have to spend more money or take more risk to finish it faster. That's why it's so essential you understand the critical path of the project because it influences how you deal with variances to the schedule.

Now, if a task now in terms of cost, if a task is self-performed, we have a lot more control over it. We can look at its specific root cause about it and we can try to address it. But again, potentially if it's an underestimated task, there's not much we can do about it. We might just have to cop it.

When we have a subcontracted task that's over budget, it's because of variation. So the subcontractor is claiming for additional work. Might be because it was procured badly and there are a whole lot of variations. Then it comes down to contract management and how can we manage these variations in a way that we spend the least possible money to get the most work done. or it might be the subcontractor is over over claiming and being unreasonable and we just have to administer the contract better. So over overbudget subcontracted packages it's going to come down to contract administration and contract negotiation to how we manage that.

Now the final part in this step-by-step system is reporting and forecasting. Similar to what I was saying at the start of this course that anyone can dump a whole lot of data and information and cost codes and percentages into a table and show a ton of information. The core thing you need to get good at as a project controller is how do you turn the raw data into a story that clearly, succinctly, and easily explains what's happening right now, why it's happening, what's going to happen next if nothing changes, and what you plan to do about it. You need to find a way to turn this into a dashboard that clearly explains the key metrics, the key messages. Because at the end of the day, if you present someone too much data, they don't do anything about it. All the previous steps, tracking quantities, tracking cost, all that stuff is wasted effort. Data without action is wasted effort. So the core thing we want to get out of all this data, all this information is some change to behavior. We want management to agree with our plan to o to to add additional resources to finish that task faster. So the questions you should be asking yourself is what insights actually matter? What can we do something about? What do we have control over? What's changed? What corrective actions are we taking? And what levels of details matter? You should never present someone with a problem. You should always present someone with solutions. So the data the analyst analysis you do identifies the problems. Your job is to come up with the solutions and present it in a way to come up with the best possible solution to the challenge. The end of the day it's not about data. It's about decision making and fundamentally what action are you taking to improve project performance.

So now we broadly understand the steps in the process to monitor and control a project again to implement this feedback loop so our plan matches reality. Let's now explore the specific tools and techniques you can use to put this into action. Previous step we spoke broadly about the steps. We spoke about cost tracking updating your schedule and so on so forth. This section we're going to get into the specific mechanisms of how you do that. So the first tool we're going to talk about is a cost tracking sheet or a cost forecasting sheet. Now this is how we know exactly where our money is going and where you're heading financially. Generally you want one spreadsheet or one tool. There's softwares that do this as well where you track every dollar you're spending. You capture those in your cost codes and against each cost code you have a forecast cost to complete the project. Again, like we spoke about in the previous step, we're going to break our scope into cost codes or work packages. We then track the budgeted cost. So, the original cost, any adjustments to that from variations, say we get in a variation to extra work, we need to adjust our budget accordingly. We then track our committed costs, so any purchase orders or subcontracts. and in addition to that our actual cost through invoices, payroll, material purchases. Using this information we can forecast our final cost which will also rely on quantities of work complete and production rates which gives us our total cost to complete the work. In addition to this, we can use this information to prepare cash flow forecast and basically predict at the point in time when these costs are going to hit.

So I'm now going to show you an example cost tracking sheet that you can use. Okay. So this is an example cost tracking sheet where you can see on the left hand side there are a series of cost codes where all the project scope is broken down into buckets of money. So we've got project management and supervision, site setup and amenities, inductions, safety briefings, temporary works, fencing. We've got the concrete works, the formwork for the footings which has a budget of 600 hours and a rate of $100. And adding these all together, we've got the total cost to deliver the project. Importantly, this is cost. So profit and corporate overheads have been pulled out of this. So what we build a client would be more than that because we'd also have our profit and our margin or whatever our lump sum fixed fee is. So, we've got our cost codes with our budgets, which are broken down by quantity and a unit of measure and a rate. So, for example, steel fabrication, we've got 75 tons at $2,800 a ton, which gives us a budget of $210,000. This is what is in a bucket of money. On top of that, these buckets of money will be adjusted through variation. So, say for example, the client has delayed us and we got a variation or an extension of time for four additional weeks at a rate of $10,000. We've got a variation amount of $40,000 of costs allocated to that. So, our new budget for project management supervision is $160,000. Our original budget plus the variation amount. Now, against each of these costs, we want to track. So, the cost code, we want to track our cost to date. So everything we've spent so far. The way we do this is with a cost tracker. Cost track is super simple. Basically every expenditure we have gets tracked in this. Say we have a subcontractor construct IQ that has done a week of work and we've paid them $6,200 and they're providing project management and supervision support. At $6,200 gets allocated to cost code 101. You can see the cost to date on cost code 101, which is our project management supervisions, is $6,200. Now, you could put anything in here. You can put, say, for example, we buy formwork materials and we've got our budget for formwork materials. Then we'd put in the invoice for formwork and then it would get allocated to the cost code. Now we can then also in the same sheet against each of our cost codes we want to forecast our cost to complete. Typically we would do this based on two things. A quantity to complete and a rate to complete. Say for example our project management supervision code. We've got a quantity to complete of 22 and a rate to complete of 13,225. So, say we're actually spending $13,225 a week on our overheads and we've got 22 weeks left to do. That gives us a forecast cost to complete of the quantity to complete multiplied by the rate to complete. So, that is how much money we need left to do the work. And then our cost at completion is the sum of our actual cost, what we've spent to date, plus the cost to complete, which gives us then our cost at completion and then our gain and loss. So why is this in the red? Well, because we're saying we need to spend $297,000 across the project to do this work, but our budget, including the variation, is only $200,000. So we're going to spend $97,000 and $97,150 more than our budget and we've got an explanation there. So we need an additional project engineer and the supervisor rate we had in the estimate was too low too too low and there's project durations also increased. So basically to forecast we want to do that for every single one of our cost codes. We needed to know the quantity to complete and the rate at completion. So you can see some of these other cost codes are showing again. For example, I'll use this one as an example. That is the formwork for the slabs. Our budget was8 850 hours at $100 an hour. Our quantity to complete, say we subcontracted it out to a subcontractor. The quantity to complete is one lump sum subcontract fee at $64,974. Now, it's just an example, might be something different. Then that would show a gain on that cost code. You sum all your gains and losses together and you get an overall financial position. So for this project, as an example, we're $240,000 over our cost. That doesn't necessarily mean we're going to lose money on the project, but our profit margin might be 50% in which case that gain or loss, which is about 12%, we could we would still make money on the project. They're just showing us where we are against our baseline cost. That's cost tracking and forecasting. Cost tracking forecasting. It's generally at a static point of time. We might use the schedule to forecast cost. For example, that project management supervision cost code. We said there were 22 weeks left on the project. That would come from schedule. But we can enhance our cost management using time phase costing and cash flow forecasting. Basically, this is taking our cost forecast and adding the dimension of time to it. So, not only do we know how much we're spending, we know when we're planning to spend it. And basically, this helps us manage our cash flow. Now, most construction companies go broke because of cash flow issues, not necessarily profitability issues. You might be starting a project, you might have to put down security, then you might have to pay a month a month's work for the first month's work. Then, you put in a bill to your client for that. Then, you get paid 30 days after that. You've actually put up two months of work before you've got any money in your bank account. So, managing cash flow on construction projects is essential. How can we track costs and schedule work together? Well, your schedule defines when the work will happen. Your budget defines how much work how much this work will cost. When you combine these, you get a timephase cost plan showing how money will be spent over time. On a construction project, this is referred to as an S-curve. An S curve is a visual representation of when we're spending, our cumulative total spend across time. So you can see they t generally take the shape of an S because when the project starts, you're ramping up. You're not doing a lot of work. You might not have many people on site. You're just getting the site sheds delivered. These sorts of things. You're not spending much money. Then you hit your bulk construction period where you have lots of people on site. You're spending a lot of money. And then you phase out as people demobilize. You tidy up, finish defects, and dem. So that's why you generally get the S the S shape. What this represents and we could talk about this a bit more when we talk about earn value management in more detail but you're basically showing your actual costs your planned progress and then your actual progress which is your earned value. So how much work you've actually gotten done. Ideally you want the budgeted cost of your work you've completed to be higher than your actual cost and that to also be higher than your plan progress because that means you're ahead of schedule and ahead of budget. So how do you develop an S curve? Well, now we're going to look at a cash flow forecasting spreadsheet that will show you how to do it. Okay, so how do we do a cash flow forecast? Super simple. It's basically we need to track when we're getting paid and when we're spending money. That's all it is. The point here is that you might have multiple clients, you might have multiple projects, you might have multiple different payment terms. So the challenge here is getting the structure right and the right information. So, for example, if you have client one that you're doing $72,000 of work in April and you have 30-day payment terms. So, day zero, you do months worth of work in that first month. Let's imagine you've spent $72,000 on labor at $72,000 out of your bank account in April. But you can only build a client for that at the end of April and they only pay you at the end of May. So that $72,000 of work you did in April, you're getting paid for it in May. Now, you might have a profit margin, so it might be less. You might have might only do $65,000 worth of work and then get paid $72,000 the next month. But the key there is that you fronted up that $65,000 in April and it's only gone back into your bank account in May. So basically, all you have to do is to set up a table like this. You have to put in when you're likely to receive payment based on the work you're completing and the payment terms with the client. Then you basically put in when and how much money you're spending and then it'll give you your net cash position. Okay, so that's cash flow forecasting and cost tracking all about money. Let's talk about how you practically monitor and control schedules. Well, in reality, you don't need to be able to do it by hand in 2025. If you're going to be using some sort of scheduling software, whether it's Microsoft Project or Primma Vera P6, when you develop your schedule, this is where you build develop the plan. And then as you deliver the project, this is where you track percentage complete against each activity and put in the actual start and finish dates. Again, it's the core thing you want to do when you're using a schedule is you want to make sure the schedule stays an accurate plan that reflects reality.

So now I'm going to show you Smart Sheet, the tool I use, which is way easier to use in Microsoft Project. I'll just show you the types of facilities and functions you'd be using. Okay, so here's Smart Sheet. It's all the scheduling softwares are the same. Doesn't matter which one you use. Basically, you're going to have a Gant chart where you're going to have your tasks, your durations, your start and finish dates, and then it's going to express itself in a bunch of lines showing when these activities occur. So to monitor and control the schedule, super easy. All you have to do is add in new tasks as they come up, adjust the linkages as they come up, and then enter your percentage complete. If I say that task is 100% complete, then it gets marked off as 100% complete. And then it's giving me some sort of overall project performance metric, which I'm sure you can adjust by putting in appropriate budget or manhour allocations to get a proper percentage complete. So that is pretty much as challenging as it gets. You're just updating that and then as required you need to update the actual start and finish date. So if this activity isn't actually starting till the 12th of June, you can see it throws out the entire schedule. Now the other thing you want to pay attention to which is a very powerful tool these scheduling softwares have is they help you understand the critical path. Critical path is the series of activities that if delayed delay project completions. It's basically the tasks with zero float. Now all you have to do to do this is well because this is a manually set date that's why that's showing that. So I actually put that back. Basically it's now highlighted. This sequence of tasks are pushing out the finish date of the project. Mobilization bulk earthworks detailed excavation concrete pour. These are the activities that we have to pay attention to. These are the activities that if for whatever reason they're going to take longer than planned, it's worth us spending more money taking on more risk. because they're what's actually driving the overall completion of the project. So, primarily using scheduling software for project controls, all you're really doing is maintaining, keeping the schedule up to date, updating with the percentage completes, which should come from your quantity tracking and monitoring the critical path. A little bit more detail on the critical path. It's basically identifying which activities control the finished state of the project. And critical path analysis is a fundamental project controls tool you need to understand because it tells you what activities matter in your schedule. You can use scheduling software to do it. An important point to note is critical path changes during the project. And if something is near the critical path, it has a float depending on the length of your project. If it has a float 5 to 10 days or less, for all intents and purposes, it's on the critical path. No schedule is 100% accurate. So if something has next to no float, it's on the critical path. The other thing you need to always pay attention to is when you're talking about the critical path is you need to understand whether an activity on the critical path is on the critical path because of resourcing or because it's got a fixed duration. For example, procurement of a building that has a 20we lead time that's on the critical path. That's different to a trenching activity that's taken 20 weeks because we've only got one crew on it. That same trenching activity, we could put four crews on it and finish it in five weeks. That same building, we can't go to four building manufacturers and get it done in 5 weeks. It takes 20 weeks to build. So, it's also important when you're talking about the critical path, you need to be crystal clear on what's a resource-driven activity, which means you can always easily add more resources. What's the proper fixed duration? Because if something has a fixed duration, it's got much more risk associated with it.

Okay. So the next tool and technique is quantity tracking which I've already spoken about at length but basically it's just measuring quantities. You can use survey data. You can go to physical counts yourself. You can get input from supervisors or workers. Really depends on the nature of the project. It's not rocket science. It's super simple. But it's basically having a point in time setting up a system and every week, every month or whatever it is, you simply record the quantity of work complete and you cross-check that with your subcontractor claims and any other information you have. But basically, you have to track your quantities for this any of this system to work at all.

The next, and I've spoken about this a couple of times already, that subcontractor management, considering 70% of project costs typically outsourced, is essential to effective project controls. Project controls without subcontractor management is pointless. You need to be able to control the costs of your subcontracted work through variations, risk, and the duration of their works. In practice, that's done through the process of contract administration. How do you do it? Well, it starts in the procurement phase where you set up a clear subcontractor scope. It's crystal clear what their pricing, what their deliverables are, when they need to finish, and that aligns with our finish dates. You need regular progress reports, regular progress meetings. You need to give them access to the site, manage it, coordinate it with them effectively, verify the percentage completes they're giving you with regular site checks, validate any payment claims, and track variations, and manage the scope tightly. Again, core principle is don't let and forget. trust but verify.

So all of these different tools and techniques, cost tracking, updating your schedule, they really tie in to a broader project management concept called earn value management, which a lot of people over complicate but is super simple. Earn value management is a project controls method that combines schedule, cost, and progress into a single system measurement. You use all of it, you can use parts of it. Basically, if you understand the fundamentals, you understand 95% of project controls. So, earn value management at its core compares what you plan to spend verse what you should have spent for the work done and what you've actually spent. Helps answer the questions of are we on budget? Are we on schedule? If not, by how much? And what does that mean for our final cost and completion dates? There's tons of formulas derived from these core inputs, but again, most of them are common sense and you can Google them in 10 seconds. But if you understand broadly what these three things are, the planned value, the actual cost, and the earned value, you understand 95% of project controls. So important principles about earn value management is earn value management only works if you have a clear cost baseline linked to each schedule activity or work package because you're using a baseline of cost to compare between different activities. If you have different units of measurement, different activities, different ways of measuring things. You need some sort of baseline to do this which is where we use the baseline of cost which is the set project budget for the task. Each activity has a planned quantity and a unit cost resulting in a planned cost. These planned costs are spread over the project timeline. The time phase them similar to an S-curve. You see they got the same shape and they create a planned value for each point in time. So if we look at this diagrammatically, you can see our earned value is the budgeted value of the work we're completing. So what is the say we've spent 50% of our say we say we've done 50% of the work the earned value would be 50% of the budget our planned value which is our schedule baseline and our cost baseline plotted over the full duration of the project and at any point in time so today in the graph that tells us how much work we should have done the difference between our planned value how much work we should have done how much work we've actually done is our schedule variance a cost variance is the difference between our actual cost remember in our cost tracker that would be the sum of all our dockets, invoices and so on verse what our earned value is. So the difference between the green line and the yellow line. If we use this information to forecast our completion, our schedule slip is going to be the difference between our forecast completion date and our plan completion date. our cost slip or our variance in cost is going to be the difference between our forecast cost to complete and our baseline cost. So if I give you some more better definitions than me just ranting about earn value management then planned value also called the budgeted cost of work scheduled. This is the approved budget for the work scheduled to be done by today. Remember earn value management it's always about taking a point in time and comparing these three metrics. For example, you plan to for pour 500 m cubed of concrete by this week at $400 per meter cubed. Our planned value at this point in time is $200,000. So we should have spent $200,000 and we should have done 500 me cubed of concrete. Remember, we're taking the metric of concrete measures cubes and we're converting it to a dollar value, our plan value, which helps us to compare it to other activities and to get an overall project picture. Our earned value is the budgeted cost of work performed. How much of what based on how much work we've done, how much of our budget should we have spent? So, we actually poured 400 m cubed of concrete using that same unit as the previous example, $400 a me cubed. Our earned value is $160,000. So what does this mean? We've earned less than our budget than we should. So this is representative of this. We're here. We've only done $160,000 worth of work. We should have done $200,000. So we're behind schedule. Actual cost. The actual cost is just tracking everything we spent so far to do that work. So this is what you actually spent so far on the work. So, for example, if the total cost to pour 400 m cubed so far is $180,000, our actual cost is $180,000. So, we've spent $180,000. We should have spent $160,000,000. Again, this is similar to this representation. Our actual costs are higher than our earned value. Particularly from this, we can calculate two key metrics. Schedule performance index and cost performance index. So schedule performance index is the ratio of our earned value how much work we should have done and how much work sorry our earned value the budgeted cost of the work we've completed over our plan value done less work than we should have it's less than one we've done more work than we should have it's greater than one so we're using that example above our earned value was $160,000 our plan value is $200,000 so our schedule performance index is8 we're behind schedule our cost performance index our the budget budgeted cost of the work we've completed is higher than our actual cost then our cost performance index is going to be greater than one. So using the numbers we calculated if our cost performance index is $160,000 divided by $180,000 we get a CPR of89 which means we're spending more money than we originally planned to. So these two metrics just give you an overall position in terms of schedule and cost.

Last tool which is essential for any smooth running construction project is a site diary. So a site diary is a daily daily record of what's happening on site. Good site diary should track all the hours for the crews they're working the materials the plant what every resource on the project is doing and it should allocate them to a Costco. So our excavator is being used for trenching in zone A. Those 10 hours of excavator usage get allocated to the cost code for trenching in zone A. You also want to track any materials delivered, any invoices, the key activities done, any issues with subcontractors as well, and any issues such as weather or access, which can be vital for substantiating pay which can be vital for substantiating variation claims to.