Education Software systems built around real operations.

Not if the project is set up correctly, and you should treat that as a requirement rather than a courtesy. Standard technologies with a real hiring pool rather than an unusual stack only we understand. Documentation written for someone who was not in the conversations. Accounts and repositories in your name throughout. No proprietary framework you would have to keep paying for. The measure is simple: if you decided tomorrow to move to another developer, how long would it take them to become productive? If the answer is more than a couple of weeks, something was built wrong.

Weeks rather than months, if the project is sequenced properly. Building in vertical slices means each release completes one journey end to end — genuinely usable rather than a layer that does nothing on its own. That matters because it lets you correct direction while correction is still cheap, and because a working thing generates far better feedback than a specification does. Projects that reveal everything at the end are the ones that overrun, since every misunderstanding compounds silently until it is expensive to unpick.

They will, and that is normal rather than a failure of planning. What matters is that changes are decided rather than absorbed. Each one gets assessed for its effect on scope, timeline and cost, then explicitly accepted or deferred. Projects overrun not because requirements changed but because they changed invisibly — a small addition here, a reasonable extra there, none individually worth a conversation, collectively consuming the budget. Making the trade visible each time keeps both sides in control of it.

For anything customer-facing, usually yes, and the cost of skipping it appears later as support tickets and abandoned journeys. For internal tools the answer is more nuanced — a competent developer working from a component library often produces something perfectly usable, and paying for bespoke visual design on a screen five staff use daily is rarely the best allocation. What cannot be skipped either way is thinking about the task: what the user is trying to finish, what information they need at each step, and what happens when something goes wrong.

By testing the conditions that occur in reality rather than the path that was demonstrated. Permissions and roles, invalid and malicious input, third-party services failing or timing out, weak networks, real devices, accessibility with keyboard and screen reader, and data quality on representative records rather than clean samples. Automated tests cover the paths that would cost money if they broke. Manual testing covers what automation cannot judge. The happy path is the easiest thing to get right and the least useful thing to test exclusively, which is why demos are a poor proxy for readiness.

Usually, and the technical feasibility is rarely the constraint. The real questions are whether your plan tier includes API access — a surprisingly common blocker — whether the API is documented and has a sandbox, and whether your IT policy permits the credentials required. Legacy or on-premise systems without an API can still be integrated through database access, file exchange or a small middleware service, with different fragility trade-offs that should be stated upfront rather than discovered. Every integration also needs failure handling designed in: retries, idempotency and reconciliation, not just a working connection.

Source code with its full history, database schema and migration record, environment configuration and how to reproduce it, build and deployment steps including rollback, test coverage and how to run it, operating responsibilities, known limitations and outstanding issues, and credentials for accounts already in your name. A repository archive is not a handover. The standard worth holding to is that a developer who has never spoken to us could set the system up, deploy a change and recover from a failure using only what was provided.

Almost never, and the instinct to do so has probably wasted more startup budget than any other technical decision. Architecture built for imagined future volume is slower to build, harder to change and usually wrong about where the load will actually appear. Build for the users you have with sensible foundations — clean boundaries, sane data modelling, no obviously quadratic queries — and measure. Scaling problems are real problems with real solutions, and they are far cheaper to solve when you can see them than to guess at in advance.