10 Critical Questions to Ask a Dev Agency Before You Sign
Most software projects do not fail because the code is hard. They fail because nobody agreed on what was being built, who would build it, who owns it, or what happens after launch. The questions below surface those gaps in a sales call instead of three months into a contract you cannot easily exit.
What this covers10
- Why these questions matter more than the portfolio
- 1. What exactly is in scope, and how are changes handled?
- 2. Who is actually going to write my code?
- 3. How is timeline accountability tracked, and what happens when it slips?
- 4. Fixed price or time and materials, and what does the quote exclude?
- 5. Who owns the code and IP, and when?
- 6. What does the handover include beyond a zip of source code?
- 7. What does post-launch support actually cover?
- 8. If you need an SLA, what are the response times and remedies?
- How Pineido answers these in one sentence: the sprint
Why these questions matter more than the portfolio
A polished portfolio tells you an agency can finish a project. It does not tell you whether your project will finish on time, on budget, or in a state you can maintain. The numbers back this up. The Standish Group's long-running CHAOS research found only about 29% of projects complete on time and on budget, and PMI research puts roughly 55% of projects through some form of scope creep, which it ranks among the top preventable causes of failure. Around 66% of software projects run over budget by various industry counts. None of that is fixed by a prettier case study. It is fixed by asking pointed questions before money changes hands, then writing the answers into the contract. The ten below are the ones that consistently separate a vendor who takes orders from a partner who protects your outcome.
1. What exactly is in scope, and how are changes handled?
Get the deliverables in writing, feature by feature, and ask the harder follow-up: what happens when something changes. One analysis suggests roughly 90% of projects need changes during development, so a 'no changes' contract is fiction. What you want is a real change-control process. A clean answer sounds like: 'Change requests go in writing, we assess cost and schedule impact within a couple of days, and nothing new starts without a signed addendum.' Projects with no formal change process are far more likely to fail. Push past 'we are flexible.' Flexible without a process is just unbilled scope creep that resurfaces as a tense conversation later.
2. Who is actually going to write my code?
This is the most common bait-and-switch in the industry. Senior architects show up to the sales call, then juniors or subcontractors do the build once you sign. Ask for named people or, at minimum, defined roles with a seniority breakdown: how many seniors, mids, and QA engineers, and a commitment that the team will not be quietly reassigned mid-project. 'We have 200 developers' is not an answer. The real question is who, specifically, is on yours. Then ask directly about subcontracting, because undisclosed subcontracting affects quality control, accountability, and who has access to your IP. A small team you can name beats a big org you cannot.
3. How is timeline accountability tracked, and what happens when it slips?
Delays happen. The question is whether you find out early or after the deadline passes. Ask for real-time visibility, not weekly email summaries. A strong answer is direct read access to the tracker, whether that is Jira, Linear, ClickUp, or similar, where you can see ticket status, blockers, and sprint velocity without asking. Then ask how they handle risk before it becomes a slip. A transparent agency tells you about a problem and adjusts the plan with clear reasoning. A weak one goes quiet until the date is blown. Tie this to a concrete cadence: how long are sprints, what does a sprint review cover, and what is your role in each cycle. Visibility you have to chase is not visibility.
Get operations insights weekly
Join service-business operators who get one actionable insight on ops, automation, and growth every week.
No spam. Unsubscribe anytime.
You’re subscribed! Look for our next issue in your inbox.
That did not go through. Please try again, or email [email protected].
4. Fixed price or time and materials, and what does the quote exclude?
Neither model is automatically safer. Fixed price feels like it puts risk on the agency, and for tightly defined, stable scope it gives you budget certainty. But when a project hits unforeseen complexity, a fixed-price vendor has one lever left to protect margin: quality. That is where corners get cut and testing gets thin. Fixed-price quotes also bake in a risk buffer, often cited around 15% to 30%, that you pay whether or not the risk shows up. Time and materials shifts cost risk to you but, when governed with a live task-and-hours dashboard, is often the more transparent model. Whichever you choose, ask what the quote excludes. Does it cover hosting, cloud bills, third-party API costs, app store fees? The gap between 'development' and 'a working, deployed product' is where surprise invoices live.
5. Who owns the code and IP, and when?
Paying for software does not automatically make you its owner. Under US copyright law the default is that an independent contractor owns what they create unless the contract transfers it. A 'work made for hire' label alone is often not enough, because software frequently does not fall into the narrow statutory categories that doctrine covers. The strongest contracts pair a work-made-for-hire clause with a present-tense assignment, language like 'Developer hereby assigns,' not 'agrees to assign,' which leaves a future step that may never happen. Ask for full ownership of source code, copyrights, and project IP on final payment. Then ask about pre-existing components and open source: the agency should disclose third-party and open-source dependencies and warrant their licenses are compatible with how you intend to use the product. This is far cheaper to settle in the contract than in a dispute later. None of this is legal advice; have your attorney review the actual clauses.
6. What does the handover include beyond a zip of source code?
Owning the code is not the same as being able to run it without the agency. If you ever switch vendors or build an in-house team, you need the knowledge, not just the files. A strong handover includes architecture and decision records, API documentation, deployment runbooks, environment and credential details, and a live walkthrough session at project end. Ask what their standard handover package looks like. If the honest answer is 'we hand over the repository,' you are buying a dependency, not a deliverable. The goal is that a competent engineer who has never seen the project can deploy and extend it from the documentation alone.
7. What does post-launch support actually cover?
Launch is the starting line, not the finish. Operating systems update annually, dependencies need patching, and bugs surface under real traffic that never appeared in QA. Ask for the support terms as a standalone document before you sign. Get specifics: is there a warranty period where genuine defects are fixed at no charge, and how long? After that, is support a retainer or billed time and materials? Crucially, ask how security work is treated, because patch management, vulnerability scanning, and dependency audits default to billable out-of-scope work if they are not explicitly named. Clarify the line between covered maintenance and new features, which are normally quoted separately. A 'fire and forget' agency that disappears at launch is a liability, not a discount.
8. If you need an SLA, what are the response times and remedies?
If your software is operationally critical, or you carry compliance obligations like HIPAA, PCI DSS, or SOC 2, a vague 'we will get to it' is not enough. Ask for response and resolution targets by severity, not one generic clock: a critical, application-down incident needs a far tighter window than a cosmetic defect. Confirm what 'response time' means, since first-response acknowledgement is not the same as a fix. If uptime is promised, ask what is excluded from the calculation, because planned maintenance windows should be scheduled, bounded, and communicated in advance. Then ask the question that gives an SLA teeth: what happens when targets are missed. You want a clear, ideally automatic service-credit formula and a defined escalation path with named roles, not 'credits on request.'
How Pineido answers these in one sentence: the sprint
We built our 30-day sprints to make most of these questions unnecessary to ask, because the answers are the product. Scope is fixed and written down before we start, at a fixed price of $8,500, so there is no open meter and no surprise invoice. You see the work in progress, not a reveal at the end. You own the code and the documentation outright when the sprint closes, and we hand over runbooks, not just a repository. Because the unit of work is 30 days, accountability is structural: if something cannot ship in the window, that is a conversation we have early, not a deadline we blow quietly. The point is not that fixed-scope sprints fit every project. It is that the transparency these ten questions are fishing for should be the default, not something you have to extract.
Frequently asked questions
Do I automatically own the code if I pay for it?
No. Under US copyright law, an independent contractor or agency owns what they create by default unless the contract explicitly transfers ownership to you. A 'work made for hire' label alone is often not enough for software, because software frequently falls outside the narrow statutory categories that doctrine covers. The safest contracts combine a work-made-for-hire clause with a present-tense assignment, the phrase 'hereby assigns' rather than 'agrees to assign,' and grant you full ownership on final payment. Have a lawyer review the actual clauses; this is general information, not legal advice.
Is fixed price safer than time and materials?
Not automatically. Fixed price gives budget certainty and suits tightly defined, stable scope, but it bakes in a risk buffer you pay regardless, often cited at 15% to 30%, and when complexity appears the vendor's main lever to protect margin is quality. Time and materials shifts cost risk to you but, governed with a live task-and-hours dashboard, is often more transparent. Match the model to how well-defined your scope really is, and in either case insist on written change control.
How do I avoid a bait-and-switch on the team?
Ask who will actually write your code, by name or by clearly defined roles, with a seniority breakdown such as how many senior, mid-level, and QA engineers are assigned. Get a commitment that the team will not be reassigned mid-project without notice. Then ask directly about subcontracting, since undisclosed subcontractors affect quality control, accountability, and who has access to your intellectual property. 'We have hundreds of developers' is not an answer to who is on your project.
What should post-launch support include?
At minimum, clarity on a warranty period for genuine defects, how support is priced afterward (retainer versus billed time), and explicit treatment of security work like patching, vulnerability scanning, and dependency audits, which otherwise default to billable out-of-scope work. Confirm the line between covered maintenance and new features, and if your software is operationally critical, get response and resolution targets by severity in a standalone support document before you sign.
How can I prevent scope creep from blowing up the budget?
Get deliverables in writing feature by feature, then insist on a formal change-control process: change requests submitted in writing, assessed for cost and schedule impact within a defined window, and no new work starting without a signed addendum. Roughly 90% of projects need changes during development by some estimates, and projects without formal change control are far more likely to fail, so the process matters more than a promise to be flexible.
What is a proper project handover?
More than a zip of source code. A complete handover includes architecture and decision records, API documentation, deployment runbooks, environment and credential details, and a live walkthrough at project end. The test is whether a competent engineer who has never seen the project can deploy and extend it from the documentation alone. If you cannot run the software without the original agency, you bought a dependency, not a deliverable.
Ready to ship?
Tell us where you are stuck. We will review it and send a focused recommendation within one business day.