| At $1M+ ARR, how to hire a web development agency is less about portfolio fit and more about surfacing how the agency actually operates after the contract is signed. The three most often forgotten: who actually does the work, what happens to your knowledge when their assigned person leaves, and how the design–content–dev handoff is managed if you’re consolidating. In this article, we break down the questions that reveal hidden operational risks, bottlenecks, and bad-fit signals. We also unpack how strong agencies actually execute a project after kickoff—from discovery and wireframes to revisions, mobile-first decision-making, and the conversion-led design that often separates strategic partners from production vendors. |
Somewhere between scaling your team and scaling your revenue, your website quietly stops feeling like an asset and starts feeling like a dependency.
Marketing needs developer support for basic updates. SEO fixes sit in backlogs for weeks. Landing pages take longer to launch than the campaigns they’re meant to feed. Nobody on your team understands how the site actually works anymore. Only the agency that built it does.
On paper, everything still looks fine. Traffic is steady. The site is live. Revenue hasn’t collapsed. But operationally, the website has gotten heavier. Slower. Harder to move with.
Every small ask turns into a ticket, a quote, and a two-week wait. The agency isn’t being unreasonable. They’re an agency. They were scoped to deliver a build, not to compound your growth.
This is usually the moment $1M+ ARR founders realise they didn’t hire a growth partner. They hired a production vendor.
And most agency evaluation advice completely misses the difference. Portfolio questions, timeline questions, and price questions all test whether an agency can ship. None of them tests whether the agency can move at the speed a scaling business actually needs.
The difference between a vendor and a long-term growth partner usually shows up in the operational details that founders ask too late.
For edtech and e-learning founders specifically, the dependency problem often shows up at the worst possible time, like during a cohort launch window or a seasonal enrolment push. The site slows down, a registration form breaks, or a landing page that was supposed to go live before the campaign opens is still sitting in a ticket queue. At $1M+ ARR, your site is not a brochure. It is part of your enrolment infrastructure. The agency you hire needs to understand that.
The 3 questions most founders forget to ask, and why they matter most
These are the questions founders usually discover too late — after delays, dependency, and operational friction have already set in.
1. Who actually does the work, not who’s on the call?
The single most reliable pattern across bad agency hires: the people who pitched you are not the people who build your site.
As one developer put it in a widely shared piece on the agency sales pattern, “senior engineers do the sales pitch, while junior engineers do the work.”
Ask, by name and role: who will write the code? Are they full-time employees, contractors, or offshored? What percentage of their week is yours?
A founder writing on Dev. to describe what happens when this question doesn’t get asked: the agency “outsourced everything and just passed messages along like a game of broken telephone.”
If your site connects to an LMS like LearnDash, Moodle, or a custom course platform, ask specifically whether anyone on the assigned team has shipped that integration before. Many “WordPress agencies” will quietly outsource the LMS work to a contractor they have never met.
Get the names. Get them on a call before you sign.
2. What happens to our knowledge when the person leaves your agency?
Most agencies don’t document in real time. They document when someone is leaving, which means the documentation is written by someone who is already mentally elsewhere, about a project they are have stopped caring about .The risk is that your project’s logic, history, and quirks leave with them. Research from CAST Software found that 74% of organisations lack a formal method of capturing institutional technical knowledge.
Ask: what documentation lives outside any one person’s head? Where is it stored? When was it last updated? Can you see a redacted handover document from a previous client?
For edtech founders, this is especially sharp around enrolment logic, drip schedules, custom quiz flows, and LMS-to-CRM integrations. These are usually built by one person under deadline pressure, rarely documented in real time, and the most expensive to inherit cold.
If the answer is “our lead developer just knows the project,” your six-month roadmap depends on one person not getting a better offer. A real partner documents in real time, not at exit interviews.
3. How do you handle the design–content–dev handoff if we’re using you for all three?
If you’re consolidating design, content, and development under one agency, the real value isn’t the bundled invoice. It’s the handoff that disappears.
Most “full-service” agencies are three separate teams sitting in the same Slack workspace. Designs get thrown over the wall to developers. Content shows up after the build is locked. The result is the same multi-vendor mess you were trying to escape, only now you can’t fire half of it.
Ask: who owns the handoff between design and development, by role? At what stage does content get written? Can you see a real project where all three were delivered in-house?
We at WisdmLabs recently completed a Magento-to-WooCommerce migration in a week, precisely because design, content, and engineering sit in one Slack channel apart, not one agency apart. If consolidation is your real goal, this question proves the savings exist.
(See also: our approach to custom WordPress website development.)
The other 9 questions to ask before you sign
4. Can you show conversion or revenue outcomes, not just portfolio screenshots?
Every agency’s portfolio is beautiful. Beauty is the floor, not the bar. The question is whether the work moved a number.
Ask for two or three specific outcomes: lift in conversion rate, drop in cart abandonment, page-speed improvement tied to organic traffic, and revenue change in the 90 days after launch.
For ecommerce, that’s cart conversion and AOV. For edtech and elearning, it’s trial-to-paid rate, course enrolment conversion, or the drop-off point on a subscription landing page. The metric changes. The question doesn’t: did the work move a number?
If they talk about “engagement” but can’t quote a percentage point on revenue, the engagement was theirs, not yours. This is what real conversion-focused web design looks like in practice.
5. How does your team actually break down, and what’s senior versus junior?
Ask for an org chart of the people who’ll touch your project. Then ask which model the agency runs:
| Model | Cost | Speed | Trust signal |
| Fully in-house | Higher | Faster execution once started | Highest, if proven |
| Hybrid (in-house leads + verified contractors) | Mid | Most flexible | Strong if leads are senior |
| Fully offshored or subcontracted | Lower | Variable | Depends entirely on whether it was disclosed and how leads are structured |
None of these is automatically wrong. The wrong answer is the model you weren’t told about. A real bench means the agency can name senior engineers by role and explain what percentage of work is contracted.
A recurring complaint across/webdesign agency threads is from developers rebuilding sites for clients who paid a “premium agency” and quietly received offshore quality.
For long-term engagements, see our breakdown of 9 projects where a WordPress retainer company works best, or how we structure things when you hire WordPress developers on retainer. Honest model plus named seniors equals real bench.
6. What’s your real response time when something breaks at 11 pm?
SLA documents are written by lawyers. They will not tell you what happens at 11 pm before a Black Friday launch. Ask instead for a real example: “Tell me about the last time a client’s site broke after hours. What happened, who picked it up, and how long until it was fixed?”
For an ecommerce founder, that 11pm break is Black Friday. For an edtech founder, it is 30 minutes before a cohort launch goes live, or the morning enrolment opens for a seasonal push. The pressure is the same; the recovery time is what gets remembered.
We had a client whose subscription payments broke, and recurring revenue stalled overnight. At WisdmLab,s we restored 100% renewal success in 30 hours. The number that matters isn’t the SLA. It’s the last real recovery.
7. Establish ownership and exit terms before the relationship starts
Ask this before you sign, not when you want to leave. By the time you’re trying to exit the relationship, the agency already knows something is wrong and the conversation becomes adversarial. Before signing, it’s just operational due diligence.
What you need confirmed in writing: you own the codebase on final payment, DNS and analytics access transfers immediately on request, and there is a named off-boarding timeline, not “we’ll figure it out.”
Founders who skip this question are the ones paying a second agency to rebuild what the first one won’t hand over.
Good website management services include clear ownership terms from day one.
8. How is scope creep priced, and who decides what’s in scope?
Scope creep isn’t a planning problem; it’s a pricing problem. Every agency handles change requests. The ones to avoid bill every change like discovery: another quote, another delay, another five-figure invoice for what should have been a 30-minute fix.
Ask for the change-request policy in writing before signing. How are small in-flight requests handled? What’s the threshold above which a request becomes its own scope? Who signs off? An agency that can’t show you this document on the sales call hasn’t built one.
9. Who’s accountable when something goes wrong across teams?
The “great agency, no single owner” red flag is real. Three teams, three managers, no one with the authority to make a decision in the room. Ask for a named project lead with override authority across design, content, and engineering. If the answer is “we discuss it as a team,” you’ll be the one resolving every disagreement.
One name. One number. Decisions in hours, not weeks.
10. Is your discovery process billable, or is it free?
Counterintuitive, but billable discovery is often the better signal. A free discovery is a sales tool. A billable discovery is a contract for actual strategic work, and the agency will invest accordingly.
Ask what the discovery deliverable is. A real discovery produces a written scope, a technical architecture, and a fixed-price proposal you could take to another agency for a second opinion. That’s worth paying for.
An edtech founder rebuilding a course platform needs a technical architecture document before a single line of code is written. An ecommerce founder rebuilding on WooCommerce needs a data migration plan, not a mood board. Billable discovery produces both. Free discovery produces a proposal that locks you in.
How the Plan Actually Gets Executed?
Most agency-evaluation guides stop at “can they deliver?” The harder question is whether they can translate your business logic into a build your team can actually run after launch.
Five operational realities sit between brief and launch. They’re the ones evaluation guides skip and bad-fit agencies fumble. If you’re at $1M+ ARR and the agency in front of you can’t answer these in specifics, you’ve found a hidden bottleneck before signing, which is the entire point of this exercise.
Handling complex workflows: who absorbs the complexity, you or your users?
Strong agencies absorb operational complexity into the design. Weak agencies pass it to your end users.
Your business probably has more moving parts than a typical website template was built for. Multiple pricing tiers, different user types, conditional logic, edge cases. The question is: does the agency figure out how to hide that complexity from your users, or do they just put it all on the page and call it done?
Here’s what that looks like in practice.
Say you run an online learning platform with six ways to enrol — free trial, paid course, cohort, group licence, scholarship, and corporate. A lazy agency builds a page with six options and leaves your visitor to figure out which one applies to them.
A good agency asks: what does the user already know about themselves when they land here? Then they design one starting question — “are you enrolling for yourself or your team?” — and branch from there. The six paths still exist. The user just never sees all six at once.
Or take a SaaS product with three plans, but the “right” plan depends on team size, use case, and billing cycle. A weak agency puts a comparison table with 18 rows. A strong agency builds a two-question flow that ends with “looks like you’re a fit for Growth — here’s why,” and buries the full table for people who want to dig.
The test isn’t whether the agency has done complex projects. It’s whether they solved the complexity or just displayed it.
| Ask the agency to walk you through a specific UX decision they made that simplified a messy backend process. If they can describe the friction they identified, the user journey they mapped, and the trade-off they made, you’re talking to a partner. If they describe a UI they built, you’re talking to a vendor. |
Operational complexity should live in the backend. Users should see one obvious path.
Execution process: brief, wireframe, visual design (and what happens between)
A strong project follows a structured execution path: discovery, requirements gathering, UX thinking, visual design, development, QA, staging review, launch, and post-launch monitoring. What changes from project to project is how formal each stage needs to be.
Some agencies use detailed wireframes before visual design. Others move directly into visual design when timelines are compressed, the UX is relatively straightforward, or content is still evolving. In these cases, UX decisions are often resolved through collaborative reviews and faster feedback loops rather than standalone wireframing.
Neither approach is inherently better. What matters is whether the agency has a clear process for reducing ambiguity before development starts.
For complex builds—multi-role dashboards, LMS workflows, ecommerce logic, onboarding systems, or highly custom user journeys—agencies often introduce an additional planning layer to surface friction early. That may take the form of wireframes, UX flows, annotated mockups, or collaborative workshops, depending on the project.
But on faster-moving projects, marketing sites, or builds where content is evolving until late in the process, agencies may intentionally move directly into visual design to avoid unnecessary review cycles and timeline delays. In those cases, UX decisions may be resolved through annotated mockups, collaborative workshops, or tighter design reviews instead of standalone wireframes.
For an edtech rebuild, the planning phase might cover the course catalogue, enrolment flow, learner dashboard, and certificate logic before development begins. For ecommerce, it may involve validating cart, checkout, and post-purchase journeys before visual polish starts.
| Ask the agency how they reduce ambiguity before development begins. Do they use wireframes, annotated mockups, UX flows, requirement documents, or collaborative reviews? The format matters less than the clarity. What you’re looking for is evidence that key decisions are made intentionally, not discovered halfway through development. |
The strongest agencies know when a lightweight process is enough and when complexity requires more structure. What matters is not whether every step exists formally, but whether important decisions are made intentionally before development moves too far ahead.
Revisions and disagreements: structured collaboration, not subjective ping-pong
Every design phase should have a defined number of revision rounds (two or three is common) and a documented process for what happens after.
Beyond round two, changes get scoped as new work. This isn’t the agency trying to charge you more. It’s the only way to prevent the design phase from quietly consuming the development budget.
The harder question is what happens when you and the agency disagree on a specific decision. The answer should never be “let’s see who feels more strongly.” It should be: the senior strategist or designer writes a one-paragraph rationale citing data, conversion benchmarks, or user-research findings. You read it, push back if needed, and decide. The decision gets logged.
If the agency’s only escalation path is a Slack thread, you’ll be the one resolving every disagreement by attrition. The agency wins by default because they have more time and more billable hours than you do.
| Ask the agency: “How many revision rounds are included, what happens after those rounds, and what is your process when a client disagrees with a design recommendation?” If the answer is vague or depends on “figuring it out later,” expect delays, scope confusion, and decision fatigue during the build. |
Decisions need a rationale. Disagreements need a process. Neither should depend on who’s in the meeting that day.
Design-to-development handoff: the place most agencies quietly fail
This is where most agencies lose 20% of their visual fidelity, and where most founders stop trusting the team.
A real handoff looks like this: a component library in Figma that maps to a component library in code, design tokens for colour and spacing, and a design QA pass after the build, where the designer reviews implementation side-by-side with the original. If the developer interpreted something differently than the designer intended, it gets caught and fixed before launch, not after.
A weak handoff looks like a Figma file thrown over a Slack wall, followed by a developer who builds what they think it means, followed by a launch where the founder notices small differences for the next six months and quietly loses confidence in the team.
| Ask the agency: Who owns design QA, by name? When does it happen in the timeline? Has a build ever gone to launch and needed a post-launch design correction, and how did the team handle it? Real answers come from teams that have actually shipped together. Vague answers come from teams that haven’t. |
We at WisdmLabs run design and development in one pod for exactly this reason. When WordPress website development and design sit on the same team, the handoff becomes a daily standup instead of a milestone, and visual fidelity stops being a debate at launch.
If the handoff is the weakest link in the agency’s process, the launched site is the weakest version of the design you approved.
11. How will you work with our existing tech stack and internal team?
At $1M+ ARR, you have an existing stack, an internal team, and processes that work. The agency needs to fit into them, not the reverse. Ask about CI/CD, staging access, code-review practices, and how they coordinate with your marketing or product team.
If they need full admin access on day one, that’s a red flag. If they describe a clear integration model with staging, code review, and limited production access, that’s a green one.
For edtech and elearning businesses, “tech stack” usually means a WordPress site plus LearnDash, Memberium, BuddyBoss, an email tool, a CRM, and often a webinar or video-hosting integration. The agency needs to demonstrate fluency in the integrations, not just the WordPress core.
Often, hiring a specialist developer with the right framework experience matters more than the size of the agency.
12. What contract protections do we both get?
This is the question that turns standard agency RFP questions into a real evaluation. Confirm in writing: IP and code ownership transfers to you on final payment; NDAs cover all subcontractors; payment is tied to milestones, not calendar dates; the contract names the lead developer; and there’s an indemnity clause for IP claims.
If the agency proposes a one-page agreement, walk. If they hand you 30 pages of boilerplate with no schedule of deliverables, also walk. This applies whether you’re hiring for a fresh build or a specialist WooCommerce migration.
| Score your finalist agency: an 8-point checklist (Quick assessment) Take this scorecard into your final sales call. Score one point per “yes”: 1. Did they name, by role and name, who will write the code? 2. Did they show you a sample handover or documentation artefact? 3. Can they describe the in-house design-to-dev handoff in one specific past project? 4. Did they quote a revenue or conversion outcome, with a real percentage? 5. Did they describe a real after-hours recovery, with a real time? 6. Did they show you the off-boarding clause in their contract? 7. Did they hand over a written scope-change policy? 8. Did they name a single project lead with cross-team authority? Score 7–8: You’re likely speaking to an operationally mature partner, not just a delivery vendor. Move into the final scope, references, and contract review. Score 4–6: There may be capability here, but there are also gaps that could become expensive under pressure. Revisit the unclear answers before signing anything. Score 0–3: You’re being sold to, not evaluated. At your revenue level, the cost of a bad agency hire is not just the invoice, it’s the three to six months of momentum you lose rebuilding what they couldn’t deliver. Keep looking. One final rule: If the agency becomes defensive when you ask these questions, that’s part of the evaluation, too. Mature partners expect operational scrutiny from scaling businesses. |
FAQs
How much does it cost to hire a web development agency at $1M+ ARR?
According to Clutch’s web development pricing data, typical agency projects average around $66,500 with engagements running roughly nine months. For $1M+ ARR businesses, expect six figures for a serious rebuild, plus a monthly retainer of $3,000–$15,000 for ongoing development.
Should we hire an agency or build an in-house web development team?
Build in-house if web development is core to your product. Hire an agency if it’s core to your channel. Most $1M+ ARR businesses run a hybrid: an internal lead who owns the product, and an agency that absorbs surge capacity, redesigns, and specialist work.
How long does a typical web development agency engagement take?
Discovery runs two to four weeks. A full rebuild for a revenue site usually runs three to six months. Ongoing retainer engagements roll month-to-month after launch and are most common in mature businesses with frequently changing sites.
What’s the difference between a freelancer, an agency, and a retainer?
A freelancer is one person: cheap and brittle. An agency is a team and a process: slower and more reliable. A retainer is recurring agency capacity with priority response, best for revenue sites that change often.
How do we know if an agency is quietly offshoring our project?
Ask for full names and LinkedIn profiles of the developers assigned to your project before signing. Confirm whether they are employees or contractors, and where they’re based. If the agency hesitates, the answer is offshoring; you weren’t sold.
Do we need a specialist agency for an LMS or course platform, or can a generalist web dev agency handle it?
A generalist can handle it if they have shipped LMS work before and can show you the projects. Otherwise the course content migration, the enrolment and subscription flow, and the quiz or certificate logic all become learning on your dime. For a major rebuild, a specialist is usually worth the premium. For ongoing development, a generalist with proven LMS experience often wins.
