Not all agencies are like this, but I’ve heard too many stories from clients. This list aims to help you and your project managers identify red flags during interviews and proposal reviews, and ensure your digital assets are built for long-term success.
The “aesthetics-first” trap
Many agencies prioritize visual trends over information architecture, resulting in attractive sites that suffer from cognitive overload due to excessive animations and large images without a clear visual hierarchy.
The harm: If visitors cannot understand your value proposition within five seconds, they leave. High visual complexity also slows load times.
Instead, require a discovery phase and ensure the agency focuses on the user journey and mobile-first responsiveness.
Over-engineering and “framework chasing”
Developers sometimes use complex architectures, such as microservices or experimental JavaScript libraries, for simple business needs.
The harm: This creates technical debt, resulting in a fragile system that is difficult to maintain. If the agency is unavailable, hiring a new developer to navigate their custom setup can be costly.
Instead, use stable, mature tools like WordPress, React, or Shopify unless the project truly requires custom solutions.
Ignoring accessibility and “SEO-afterthought”
Treating SEO and accessibility (including ADA compliance) as afterthoughts to address post-launch.
The harm: Non-accessible sites pose legal risks, and sites lacking semantic HTML and schema markup are difficult for search engines to index.
Instead, integrate technical SEO and accessibility audits into every development milestone. You can audit the site yourself with this tool.
Poor project transparency
Vague proposals that list “Website Development” as a single line item without breaking down phases like Discovery, Wireframing, and QA.
The harm: Leads to unanticipated expenses mid-project because requirements weren’t properly mapped.
Instead, require milestone-based deliverables and a clear timeline with regular checkpoints for approval.
Lack of post-launch support
Agencies that hand over the site and provide no support after launch.
The harm: Websites need ongoing security updates and performance monitoring. Without support, your site may become vulnerable or stop functioning properly.
Instead, negotiate a maintenance and support package before signing, and ensure you have full ownership of your domain and hosting.
Using proprietary CMS (vendor lock-in)
Building on a custom-coded CMS owned by the agency rather than using industry-standard platforms.
The harm: You cannot easily transfer your site to another host or developer, resulting in vendor lock-in.
Instead, choose an open-source or portable CMS so you own the code and can hire any developer in the future.
The “silent handover” (no documentation)
Delivering a site without instructions for use or maintenance.
The harm: Your team will not know how to make minor updates, such as editing blog posts or prices, which forces you to rely on the agency for simple changes.
Instead, include training and documentation, such as video walkthroughs or standard operating procedures, as part of the project deliverables.
Hard-coding instead of dynamic scaling
Coding content directly into files instead of making it editable through a dashboard.
The harm: Any change, such as updating a phone number or headline, requires a developer, which slows down your marketing team.
Instead, request a modular or block-based build where all key text and images are managed through CMS fields.
Ignoring the “performance budget”
Installing numerous heavy plugins or third-party scripts, such as trackers or chatbots, without considering their impact on site speed.
The harm: Each script slows the site, reducing conversion rates and increasing bounce rates.
Instead, set a performance budget, such as a target Google PageSpeed score of 75 or higher, and justify every third-party script.
Forgetting to account for “edge cases”
Designing only for ideal scenarios, such as perfect text length and image size.
The harm: Adding longer headlines or differently shaped images can break the design and make it appear unprofessional.
Instead, ensure the developer creates resilient containers that adapt to varying content lengths and formats.
