The Founder's Pre-Hire Checklist for Dev Agencies

You're about to wire $15K-50K to a development agency. Maybe more. This might be the biggest investment your startup makes before revenue.

And yet most founders spend more time choosing a restaurant for dinner than evaluating a dev agency. They look at the portfolio, check the reviews, maybe have a nice call — and sign.

Here are 7 things to demand before you send a single dollar.

1. A Written Scope of Work

Not a proposal. Not a slide deck. A detailed specification document that covers:

• •Every feature, broken down into specific requirements
• •Every screen or page, with expected behavior
• •Edge cases and error states
• •What is explicitly NOT included
• •The tech stack and why
• •Fixed price based on the above

If an agency can't produce this before you sign a contract, they haven't thought through your project. And if they haven't thought it through, they're going to figure it out on your dime — which always costs more.

A good spec takes 3-5 days to write. Any agency that claims they need less than that either has a template they're reusing (not ideal) or they're not being thorough enough (definitely not ideal).

2. Access to a Previous Client's Code

This one makes agencies uncomfortable. Good.

Any reputable agency has at least one former client who would let a prospective client's developer review the code. If the code is clean, well-tested, and well-documented, the agency should be proud to show it.

What to look for (have a developer friend review):

• •Is there a clear folder structure?
• •Are there automated tests?
• •Is the code well-commented?
• •Is there a README with setup instructions?
• •Are environment variables properly managed (not hardcoded)?

If the agency refuses this request or makes excuses, ask yourself: what are they hiding?

3. The Names of Who Will Work on Your Project

Not "our senior team." Not "our best engineers." Names. LinkedIn profiles. Their actual previous work.

Many agencies have a bait-and-switch problem. Senior developers do the sales call. Junior developers do the actual work. You're paying senior rates for junior output.

Ask specifically:

• •Who will write the code?
• •Who will review the code?
• •Are these the same people you're talking to right now?
• •What happens if one of them leaves mid-project?

At CodesSavvy, the engineers you talk to are the engineers who build your product. We don't have a sales team.

4. A Deployment Plan

Before any code is written, you should know:

• •Where will the application be hosted? (AWS, Vercel, GCP, etc.)
• •Whose account will it be deployed on? (Yours. Always yours.)
• •Who sets up CI/CD?
• •Who has access to production?
• •What's the rollback plan if a deploy goes wrong?
• •Who owns the domain, SSL certificates, and DNS?

This might seem like a technical detail that doesn't matter. Until your agency ghosts you and your app is running on their infrastructure with their credentials.

We've rescued projects where the founder literally couldn't access their own application. Don't be that founder.

5. A Communication Schedule

Before signing, ask for specifics:

• •How often will you receive updates? (Daily written updates should be the minimum)
• •What tool will you use? (Slack, email, Notion — doesn't matter as long as it's defined)
• •When are demos? (Weekly. Non-negotiable.)
• •What's the escalation path if something goes wrong?
• •What timezone overlap exists for real-time communication?

Agencies that are vague about communication will be vague about everything. If they can't articulate their communication process before the project starts, they don't have one.

6. Their Testing Strategy

Ask: "How will you ensure this works?"

Bad answers:

• •"We test manually before delivery"
• •"Our developers are very careful"
• •"We'll do QA at the end"

Good answers:

• •"We write unit tests for business logic and integration tests for API endpoints"
• •"Every PR goes through code review before merging"
• •"We maintain a staging environment that mirrors production"
• •"We have automated tests that run on every commit"

Manual testing alone is not a strategy. It's a hope. And hope is not a deployment strategy.

7. Their Handoff Process

The project will end. What happens then?

Ask:

• •What documentation do I receive?
• •Is there a knowledge transfer session?
• •Will another developer be able to pick up this code without calling you?
• •What's included in post-launch support?
• •How long do you support bugs after launch?

A clean handoff should include:

• •Full access to the code repository (on your account)
• •README with setup, deployment, and architecture overview
• •Environment variables documented
• •Architecture decision records (why certain choices were made)
• •A walkthrough session with the founder and any new developers

The Meta-Test

Here's the real test that covers all 7 points: Ask the agency to answer all of these in writing before your second call.

A great agency will appreciate the thoroughness. They'll answer everything clearly because they already have these processes in place.

A mediocre agency will be annoyed by the questions. They'll give vague answers or say "we'll figure that out as we go."

That reaction tells you everything you need to know.

How CodesSavvy Answers These

We share all 7 on our first call. Our spec documents are detailed. Our repos are hosted on the founder's GitHub from day 1. You meet the engineers who'll build your product. And we've never had a client lose access to their code — because it was never ours to keep.

Save this checklist. And when you're ready to see how we answer each point, book a free scoping call.