I have lost count of the number of projects where the conversation goes like this. The go-live date was agreed months ago. Development is running late. The business has already told customers, the regulator, or the board. And somebody turns to the testing team and asks: can you still fit it in?
The honest answer is usually yes. But not the way it was originally planned.
This post is about how I handle testing under a tight deadline when development is still happening. It covers functional testing, user acceptance testing (UAT), and the decisions that get you to the go-live date without gambling the business on it. I have kept it simple on purpose. If you are a project manager, a product owner or a CTO who is not a tester, this is written for you.
First, accept what has actually happened
When the deadline is fixed and development slips, you have lost testing time. That is just arithmetic. The mistake teams make is pretending they have not, and running the original test plan in half the time. That plan was written for a different project. The one you have now needs a different plan.
So the first thing I do is stop and re-plan, even if it costs half a day. Half a day of planning saves weeks of testing the wrong things.
Decide what must work on day one
Not everything in the release carries the same risk. On a payments platform, the thing that must work is the money moving correctly. On a lending product, it is the credit decision and the affordability check. On a customer portal, it is login, the main journey, and anything that touches personal data.
Sit down with the product owner and the business, and agree a short list. I call it the "cannot go live without" list. It is normally five to ten things. Everything else is important, but it is not on the list.
This is risk-based testing in plain terms. You test the things that would hurt most if they broke, first and deepest. The things that would be embarrassing but survivable get lighter coverage. The things nobody would notice for a week get a smoke test or wait for the next release.
Writing this list down and getting it signed off is the single most valuable thing you can do under time pressure. It turns "we did not have time to test everything" from an excuse into a decision the business made with its eyes open.
Start testing before development finishes
The biggest time saver is not waiting. Most teams plan testing as a phase that starts when development ends. Under a tight deadline, that phase does not exist. You test in parallel with development, feature by feature, as each one becomes ready.
That means a few practical things.
Test what is finished, not what is planned. If the payment screen is done but the statement download is not, test the payment screen today. Do not wait for the full build.
Get a test environment early and keep it stable. Nothing wastes time like testers waiting for an environment, or testing against a build that changed overnight. Agree with the developers when code gets deployed to test, and stick to it. Twice a day is fine. Random is not.
Write test cases from the requirements while the code is being written. Testers do not need working software to prepare. They need to know what it is supposed to do. By the time the feature arrives, the tests are ready to run.
Fix the environment and data problems first. Under pressure, half the testing time disappears into test data that does not exist, accounts that cannot be set up, or integrations that are not connected. Sort these out in the first week, not the last.
Run functional testing and UAT at the same time
This is the part people push back on, so let me explain it.
Functional testing is the testing team checking that the software does what the requirements say. UAT is the business checking that the software does what they actually need. The traditional view is that UAT comes after functional testing is complete and clean. On a comfortable timeline, that is correct. On a tight one, it is a luxury you cannot afford.
What I do instead is overlap them. As soon as a feature has passed its main functional tests, it goes to the business users for acceptance, even while the testing team is still working through the edge cases on it. The business is testing the happy path and whether it makes sense for them. The testers are testing the boundaries, the error handling and the awkward combinations.
Yes, the business will find some defects that the testers would have found anyway. That is fine. It is far better than the business seeing the software for the first time in the last week, finding something fundamental, and the whole go-live date moving.
Make UAT small, focused and real
UAT fails under deadline pressure for the same reasons every time. Too many testers, no clear scope, no time blocked in diaries, and nobody deciding what happens when they find a problem.
Here is what works.
Pick a small group. Three to six business users who know the process well and are available. Not the whole department.
Give them scripts, not freedom. Under pressure, UAT should be guided. Give each user the five or ten real scenarios they would do on a normal day, with the data already set up. Leave a little time for them to explore, but make the scripts the priority.
Block the time in their calendars. UAT that is "whenever you get a chance" does not happen. Half-days, booked, with the testing team on hand to help.
Use real scenarios and realistic data. A payment of ten pounds to a test account tells you very little. A month-end batch with the volumes you actually see tells you a lot.
Agree what a blocker is before you start. A defect that stops a user completing a core journey is a blocker. A label in the wrong place is not. Write this down. It stops the last week turning into an argument about whether a cosmetic issue should stop the launch.
Triage every defect against the go-live list
When time is short, you will not fix everything. The question is never "is this a bug?" It is "does this stop us going live?"
I run a short defect triage every day during the final weeks. Each defect gets one of three answers: fix before go-live, fix in the first week after go-live, or accept and log. The product owner makes the call with the information in front of them. The testing team gives the risk honestly. Nobody is allowed to say "we will see".
A known list of accepted defects, with a date for each fix, is a perfectly respectable thing to go live with. An unknown list is not.
Protect the last three days
Whatever happens, do not let development continue right up to the go-live date. The final few days need a frozen build. No new features, no refactoring, only fixes for agreed blockers, each one retested.
In those days the testing team runs a final regression on the "cannot go live without" list, the business signs off UAT formally, and someone checks the boring things: data migration numbers reconcile, the rollback plan exists and has been tried, monitoring is switched on, and the support team knows what is launching.
If development is still committing new code the morning of go-live, you are not launching. You are hoping.
Have a clear go or no-go meeting
The day before go-live, get the decision-makers in a room, or on a call, for twenty minutes. Walk through the list: the must-work items and their test status, open defects and who accepted them, UAT sign-off, and the rollback plan. Then make the decision.
If it is no-go, that is a result, not a failure. A one-week delay that you chose is far cheaper than an outage that you did not.
What this looks like in practice
To make it concrete, here is roughly how a six-week window breaks down when development will not finish until week four.
- Week one. Re-plan. Agree the must-work list. Stand up the test environment and test data. Testers write test cases from the requirements.
- Weeks two to four. Test each feature as it lands. Daily defect triage. Business users start acceptance on finished features from week three.
- Week five. Full functional regression on the must-work list. UAT on the complete journeys. Blockers fixed and retested.
- Week six. Code freeze. Final regression. UAT sign-off. Go or no-go decision. Launch.
It is tight. It works, as long as the business owns the risk decisions and nobody pretends there is more time than there is.
The one thing I would say to any CTO in this position
Hitting a go-live date with a tight testing window is not about testing faster. It is about deciding, early and honestly, what you are testing and what you are not. Teams that do that go live on time and know exactly what they have shipped. Teams that do not go live on time too, and find out what they shipped from their customers.
If you are in the middle of one of these right now and want a second opinion on the plan, that is a conversation we have often. Our QA Advisory work covers exactly this, and if you need hands to run the testing itself, Testing as a Service can be in place within a sprint. You can also read how we think about risk-based testing in more depth.
