CorLab AI Agent

This Tech Assistant is designed to support you with clear insights into our company, our work, our services and the people behind our progress.

Powered by CorLab Tech © 2025

Start strong, build smart, and launch your custom software with peace of mind.

The custom software development process runs in six stages: discovery, requirements, architecture and data model, build, testing and acceptance, and launch and handover. Each stage ends with a decision the client makes and a short written record of it. Every one of those decisions costs more to change the later it is made.

A good process settles the decisions that cause the most rework first, such as your data and your integrations, and writes each one down so nobody has to remember who agreed to what.

The six stages of custom software development at a glance

Most custom software projects pass through the same six stages, whatever a vendor calls them. The table shows what you decide in each one, the written evidence that the stage is finished, and what goes wrong when it is rushed.

StageWhat you decideEvidence the stage is doneWhat goes wrong if it's rushed
DiscoveryThe problem, the users, what's out of scopeA short brief with an out-of-scope listThe first idea becomes the plan without being checked
Requirements and specificationRules, roles, how to tell a feature worksA dated spec the real users have readGaps turn into bugs nobody notices
Architecture and data modelWhere data lives, connections, expected growthA data model and connections tested on real systemsEvery later change means rework
Build in iterationsPriorities, change requestsDemos approved against the agreed criteriaA smooth demo is mistaken for real use
Testing and acceptanceReal data, who tests, the bar for launchUser acceptance testing (UAT) sign-off and a list of open bugsYour users find the bugs
Launch and handoverGo or no-go, who holds the keysYour team releases an update without the vendorThe vendor still controls your system

 

In practice the stages overlap, so read the table as a map of when each decision should be settled rather than as a calendar. Every SDLC, or software development lifecycle, follows roughly this order; vendors differ mainly in who makes each decision. How CorLab runs these stages on its own projects is set out on the custom software development services page.

The custom software development lifecycle also runs past launch, so the last stage covers what keeps you in control afterwards. Each stage includes a moment from one of my own builds, usually one where something went wrong.


Why a late decision costs more

Take the rule for who can see a patient record. It shapes how the data is stored, which screens exist, what the reports show and what the tests check. Changing that rule while it is still a sentence in a document takes an hour; after launch, the storage, screens, reports and tests all change with it.

The curve has numbers behind it. A 2002 planning report on software testing from the National Institute of Standards and Technology (NIST) illustrates it with an example. A bug that costs 1 unit to fix during requirements or design costs 5 during coding, 10 during integration testing, 15 during beta testing and 30 after release.

NIST labels that table an example, so it shows the shape of the curve rather than a measured rate. That shape is why a good custom software development process settles the hard decisions in the first three stages, and few of them are about screens.

The three decisions that cause the most rework

Three decisions cause the most rework when they are left open. The first is the data: what it is, where it lives and who may change it. The second covers integrations, meaning which systems the software reads from or sends data to, and who answers for each one. The third is the rules the software must enforce, block or record.

Written proof keeps decisions from drifting

None of this needs heavy paperwork: a dated sign-off on the spec, a short note for each accepted sprint and a signed handover checklist. Signing off doesn't freeze the project. A later change arrives as a change request with its own estimate, so you see its effect on the schedule and the custom software development cost before you approve it.
 

Stage 1: Discovery sets what the software won't do

Discovery is where you and the vendor agree on the problem, who the software serves and what it will not do. The output is a short brief signed by whoever will own the system on your side. Bring the people who do the work today to these meetings, because they know the workarounds nobody wrote down.

In discovery, you decide:

  • the problem that's costing you money today
  • who the users are
  • the one job the first release must do
  • what's out of scope, in writing

Specific enough to build against

A good vendor keeps asking until the answers turn concrete. "Doctors need better information" sounds fine in a meeting, but nobody can build or test it. "Doctors need to check whether two medicines interact, and see the source" is something a team can build and a tester can check.

The out-of-scope list

The out-of-scope list carries as much weight as the scope. A short list of things the software will refuse to do lets you check each new idea in a minute instead of arguing over it in a meeting. It also tells the vendor which edge cases need no design work at all.

My medical AI agent started with that kind of list. My wife is a practicing doctor, and she kept running into AI chat tools that sounded certain but couldn't show where an answer came from.

So the first decisions were refusals. The agent answers only from official drug leaflets and a graph of known drug interactions, takes no action on its own, and says so when its sources hold no answer.

The line works in both directions, and large public systems draw it around what is included. The e-prescription system CorLab built with CNAM, Moldova's National Health Insurance Company, covers reimbursed medicines and medical devices, and that scope set the reimbursement rules it had to handle.

rsz_redesign_second_image2_8a71ebe657 (2).jpg

Discovery is finished when the future owner of the system has signed the brief. Rushed, it lets someone's first idea, such as "we need a mobile app", become the plan before anyone checks whether users need one.


Stage 2: Requirements turn rules into something you can test

The requirements specification, or spec, turns the brief into rules a developer can build and a tester can check. Each requirement carries acceptance criteria that state what counts as done. Your part is deciding the rules and the permissions, then reading the spec the way your users would.

During requirements, you settle:

  • the business rules the software follows
  • the user roles, and what each role may see and do
  • what each field is allowed to hold
  • the acceptance criteria for each feature

How acceptance criteria work

Acceptance criteria are where vague wishes become testable. The requirement "the system notifies the clinic about new referrals" leaves open the channel, the timing and what happens when nobody opens the notice. Each open question is a place where a referral can sit unread while everyone assumes someone else saw it.

Good criteria close each gap: an in-app alert and an email within an agreed number of minutes, and a message to the manager if nobody opens the referral in time. A demo then passes or fails against something written down.

The missing line that hid a question type

The bugs that cost most come from small gaps in a spec, because nothing breaks loudly. A missing list of allowed values is typical: data outside the list disappears without an error, and the system looks healthy while it quietly loses work.

On the live lesson platform I built for my department, an AI model suggests quiz questions for the platform to save. It labeled one question type "single_choice", while the parser accepted only "cs", "cm" and "free_text", so it discarded those questions without logging anything. The teacher simply saw fewer questions.

The prompt had never listed the permitted values. That list is exactly what the spec settles under "what each field is allowed to hold", and written there once, it gives the prompt and the parser the same names. Finding the gap afterwards meant tracing a failure that raised no error anywhere.

A spec is finished when the people who do the work have read and approved a dated version. Any gap left in it reaches production as behavior nobody chose.
 

Stage 3: Architecture and the data model are the hardest to undo

Architecture is the overall plan: where the data lives, how the software talks to other systems and how far it can grow. The data model decides how information is organized, and it is the hardest part to change later, because everything from the screens to the reports is built on it.

Fusedash dataset fields used to build chart widgets

Four architecture questions are yours to answer:

  • where the data may be stored?
  • which system holds the official version of each record?
  • how much data and how many users to expect?
  • what happens when a connected system goes down?

Let the data shape the model

The shape of the data should pick the storage. On the medical AI agent, drug interactions are links between two medicines, so they went into a Neo4j graph. The leaflets are long passages of text, so they went into a Qdrant vector store that searches by meaning rather than exact words.

Sometimes one limit decides the architecture outright. For the self-hosted BI platform, a reporting tool that runs on the customer's own servers, the first rule I wrote was that the data does not move. If a feature needs the data to move, the feature is wrong.

Every connection should be tested against the other system itself, not only against its documentation. Only the live system shows what it actually sends, how it fails and how slowly it answers.

Write the limits down

Limits deserve the same written treatment as features. A limit agreed in advance is a boundary anyone planning a rollout can budget for; one discovered by a user on a busy morning looks like a bug and gets reported as one.

The live lesson platform handles a group of 15, not a whole year group yet. The synchronized VR platform runs one server per classroom. Both limits are written into the build logs, so nobody planning a wider rollout meets them by surprise.

Security belongs in the architecture

Security work starts in this stage rather than in a review at the end. NIST's Secure Software Development Framework recommends building secure software development practices into every stage of the lifecycle. Access rules, activity logs and encryption all touch the data model, so adding them late means opening the model back up.

Architecture is finished when the data model exists, the limits are in writing and every connection has been tested on the real system. Skipping that step means the first change to the data model triggers rework across the build.
 

Stage 4: The build runs in sprints you accept or reject

The build happens in sprints, short blocks of work that usually last one or two weeks. Each ends with a demo of working software that you accept or reject against the acceptance criteria, and a demo proves something only when both sides agreed beforehand what "done" means.

Three calls are yours in every sprint:

  • what gets built first
  • whether each demo meets the acceptance criteria
  • whether to approve each change request, once its cost is known

TaskFlow board with tasks moving from To Do to Done

When a good demo isn't enough

The Scrum Guide, the standard handbook for sprint work, calls that agreed bar the Definition of Done. Work that misses it goes back to the backlog. Even a demo that meets it can hide problems, because a demo usually shows one person taking one smooth path through the software.

On the VR platform, the teacher's dashboard waited for every headset to confirm a pause before it updated. On a busy classroom network that took long enough for teachers to press Pause again, which resumed the video. A one-person demo on a quiet network never shows that delay.

How to handle change requests

Change requests prevent arguments later. Once something is signed off, a change is measured against it instead of debated. Reordering the backlog needs no paperwork, but changing an approved rule does, because other features rely on it. A good change request states what changes, what it adds to the estimate and who approved it.

A sprint is finished when you have accepted the work and approved any changes in writing. The code should sit in a repository you own from the first commit.
 

Stage 5: Testing with real data is where the surprises show up

Testing checks the software on its own, then its data exchange with other systems, which is integration testing, and finally its handling of your real work. That last part is user acceptance testing (UAT), and your own people run it before launch.

Before testing starts, you choose:

  • which real data to provide, with personal details removed
  • who runs the acceptance tests
  • which tasks must work before launch
  • which known bugs can wait, and until when

ePrescription form calculating the compensated amount and patient co-payment

What real data and real conditions catch

Test files are almost always tidier than real ones, and a test bench is quieter than a classroom or a ward. Some bugs appear only with production data, a full network or many devices at once, so acceptance testing has to run under real conditions.

The first 360° video I loaded onto a VR headset showed up as six warped squares. YouTube stores those videos as a cubemap, while the headset app expects the standard equirectangular format, so those files now go through a conversion script first.

Real conditions caught the next problem. A headset busy downloading a 2 GB video couldn't answer the server's regular check-in, so after 20 seconds the server decided it was dead and cut it off. A single test headset would never have shown it.

Testing also has to stay out of the way of real work. On the live lesson platform, test runs shared a queue with real slide imports and left 488 jobs behind, and a genuine import sat stuck behind them. The tests have their own queue now.

Acceptance on your own material

Good acceptance tests include questions with no good answer, because refusing correctly is part of the job. They are written on your own material, since a public benchmark measures someone else's data, not yours. Set the pass mark before the first run.

For the medical AI agent, I've written down how validation starts. Clinicians write realistic questions, including some the sources cannot answer, and agree on the right response to each. The agent is then scored on accuracy, on citing the right source and on declining when it should. So far the three-day prototype has been checked only by me.

Testing is finished when UAT is signed off and every open bug is either fixed or knowingly accepted with a date. Rushed testing turns the first users into testers, and each bug they find costs more than it would have a month earlier.
 

Stage 6: Handover ends when you can run the system yourself

Launch puts the software in front of real users; handover puts you in charge of it. That takes more than a copy of the source code. The real measure is whether your own team can release an update without calling the vendor, using accounts, scripts and keys you control.

Four handover decisions are yours:

  • go or no-go for launch
  • who acts if a connected system fails on launch day
  • whose accounts hold the code, the hosting and the domain names
  • the support terms after launch

Plan the launch for failure

A launch plan should assume that a connected system will fail on the day and decide in advance what happens then, because launch night is the worst time to negotiate a rollback. The plan also says who tells users what is going on.

As CorLab's guide to e-prescribing systems describes, doctors and pharmacists in Hîncești used eRețeta in a pilot before the national launch. Then, the night before launch, MSign, the government's electronic signature service, froze. It took about two hours to get signing working again.

A freeze like that is what the plan is for. It names who acts, how long the team waits for a fix and the point at which the release is rolled back.

After launch, people depend on the system every day. By April 2026, about 2,500 doctors at 1,400 medical institutions had prescribed through eRețeta. About 900,000 unique patients had used it, according to National Health Insurance Company figures reported by Logos Press. A system that size cannot live in one developer's head.

ePrescription patient details and prescription history

The handover checklist

A handover checklist turns "we gave you everything" into six items you can verify on accounts you control. Sign it only when every row passes the check in the third column, not when the vendor says the work is done.

ItemWhat you receiveHow to check it
CodeAll of it, in a repository you ownEvery branch and the full history are visible
ReleasesScripts that put a new version liveYour team has run them once
AccountsHosting, domain names, outside servicesEvery invoice is billed to you
Passwords and keysA full list, vendor access changed or removedNo credential is still known to the vendor
DocumentationHow the system works, plus an everyday guideA new team member can follow it alone
Known issuesBugs and limits accepted in testingEach one has a named owner

Prove you can run it alone

Moving the code into your account matters only when it started somewhere else. A repository the vendor built in its own account and transferred at the end can leave access behind long after the contract ends. Code that lived in your account from the first commit skips this risk entirely.

GitHub's documentation notes that when a repository moves between two personal accounts, the original owner is added as a collaborator. Webhooks, services and deploy keys stay attached after a transfer. Check who still has access, then replace every key.

The real test is a release by your team on its own. One rule I wrote for the BI platform was a single install command: if the customer's own team cannot stand it up without help, it isn't really self-hosted.

Owning the code and controlling it are separate questions. The contract decides who owns it, and the account it lives in decides who controls it. CorLab's guide to bespoke software explains why you need both, and the guide on how to choose a software development company covers the contract terms.

Support terms to get in writing

A warranty covers bugs in what was delivered, for an agreed period, and maintenance covers everything after it. Compare maintenance terms as carefully as the build price. Four of them belong in writing: response times for urgent and minor issues, who fixes what and where, how long the warranty lasts, and how changes are priced after it ends.

Handover is finished when the checklist is signed and your team has released one update without the vendor. A custom software development process that ends before that release leaves only the vendor able to change your software, so check that the proposal plans for it.

Know us better

Frequently asked questions

Hide

What are the stages of the custom software development process?

Six stages make up the custom software development process: discovery, requirements and specification, architecture and data model, build in iterations, testing and acceptance, and launch and handover. Each ends with a client decision and a short written record, such as an approved spec or a signed acceptance test.

Show

Who on the client side should sign off each stage?

Show

How long does a custom software project take?

Show

What is the difference between integration testing and user acceptance testing?

Show

What happens if requirements change after sign-off?

Show

What should a vendor hand over at the end of a project?

Show

Does an agile project still need a written specification?

Background decoration

Author

With more than 10 years in full-stack development and real-world experience in healthcare, I bring a unique blend of technical skills and domain knowledge to every project. My focus is on building solutions that solve real problems and support better outcomes.

I often bring AI into the mix to enhance performance and simplify the complex. It’s all about creating smarter tools that help people work more efficiently and make better decisions.
Mihai Dascal

Mihai Dascal

Co-founder & CTO

LinkedInLinkedInarrow
healthcare dashboard

Thinking about building your own app?

Let's make it happen! Dream big, build smart - we’ll take care of the tech.

Get a free consultationGet a free consultation

Our Best Insights

Browse More Articles

Want to know what’s trending in the tech world? Our articles break it all down - quickly and clearly.