Everything you need to know
If you have more questions, feel free to send us an email.
Design & Multimedia Faqs
Web Designers
A web designer should improve the decisions people make on the site, not simply make the pages prettier. The work sits at the intersection of visual hierarchy, navigation, content structure, brand, responsive behavior, and the path from arrival to whatever the business wants the visitor to do next.
Consider a B2B services homepage with twenty capabilities competing for attention, three different calls to action, and no obvious reason to choose the company. The design problem is not the shade of blue. It is deciding what deserves attention first, how proof should appear, where services should be grouped, and whether a visitor can understand the offer without reading every paragraph.
Good web design also anticipates real content. Headlines become longer. Case studies get added. A sales team asks for another service page. Mobile screens collapse the available space. The designer’s job is to create a system that remains understandable when the website stops looking like the perfect Figma mockup and starts behaving like a living business asset.
Web design decides how the website should work and feel. Web development turns those decisions into a functioning website. The designer typically owns page structure, visual hierarchy, typography, spacing, components, navigation behavior, responsive layouts, interaction states, and the overall user experience. A front-end developer translates that system into HTML, CSS, JavaScript, CMS templates, components, and production behavior. Back-end developers may handle databases, APIs, authentication, integrations, or other functionality the visitor never sees directly.
The boundary is not always rigid. A Webflow designer may design and build. A technically strong designer may understand CSS, breakpoints, or component logic without being the person writing production code.
Trouble starts when the responsibilities are assumed rather than agreed. A developer should not receive five desktop screens and be expected to invent every mobile state, while a designer should not suddenly discover at handoff that the client expected production-ready code.
The first serious output should usually be clarity, not polished screens. Before designing a homepage, the designer needs to understand what the business sells, who the important visitors are, which journeys matter, what content already exists, what technology the site uses, and what problem the redesign is meant to solve.
Structure often comes next. That can involve sitemap decisions, page hierarchy, content blocks, low-fidelity wireframes, user flows, or reusable page patterns. Visual design becomes much more productive once the team has agreed that a service page needs proof, process, FAQs, case studies, and a clear conversion path rather than arguing about those things after the page has already been styled.
Later stages should test responsive behavior, component states, content variation, accessibility, and development feasibility before handoff. A professional process reduces expensive interpretation downstream. It should not create fifty approval documents for a ten-page website, but developers should not have to reverse-engineer basic design intent either.
Design cannot manufacture demand. It can, however, remove a surprising amount of friction between interest and action. Suppose a company is already getting qualified traffic to a service page but enquiries remain weak.
The problem might be an unclear proposition, a call to action buried after six screens, weak proof, pricing uncertainty, poor mobile hierarchy, or a form asking for twelve fields before the visitor has built any trust. A designer can restructure those decisions so the page answers the questions people need answered before they move forward.
This is why “conversion-focused design” should not mean adding larger buttons everywhere. A Reddit discussion about a site that was receiving traffic but not converting quickly moved toward unclear value proposition, weak calls to action, and poor visual priority rather than SEO alone. The useful question is always where the visitor is hesitating and whether design can reduce that hesitation.
Web design is the practical combination of several disciplines applied specifically to websites. User Experience (UX) design concentrates more deeply on journeys, information architecture, behavior, research, and whether people can complete what they came to do. User Interface (UI) design focuses more heavily on the visual and interactive layer: controls, components, typography, spacing, states, and interface consistency.
A web designer may do substantial amounts of both. On a marketing website, they might restructure the navigation like a UX designer, then design the hero, cards, forms, and responsive states like a UI designer. Smaller businesses rarely need three separate people for every ten-page site.
The distinction starts to matter when complexity increases. A large SaaS product may need dedicated UX research and product UI specialists, while the public marketing website is handled by a web design team. Hire for the problem rather than the title.
Enough to avoid designing against them. A web designer does not need to replace the brand strategist, copywriter, or SEO specialist, but treating those functions as somebody else’s problem usually produces a website that works beautifully only in isolation.
Content changes layout. A page aimed at a technical buyer may need comparison detail, specifications, proof, and FAQs. A premium consumer brand may need more visual breathing room and less explanatory copy.
SEO can affect page hierarchy, internal linking, headings, service-page structure, and which content needs to remain accessible to search engines. Branding controls far more than color. It affects voice, visual density, imagery, typography, and how the business should feel.
Strong designers know when to bring other specialists into the conversation. Community discussions around redesigns frequently show owners struggling not only with visual design but also with where content belongs, how it should be written, and whether designers and SEO teams should be working together rather than rebuilding around one another. That overlap is part of real website work.
Many expensive development problems begin as unresolved design decisions. Imagine a team has already chosen the CMS, written fifty pages of copy, and promised launch in six weeks before a designer sees the project. The designer then discovers that the navigation needs restructuring, the page templates cannot comfortably handle the content, the mobile experience requires different component behavior, and several sections depend on functionality nobody included in the development estimate.
Early design involvement surfaces those problems while they are still diagrams and wireframes. The designer can establish page types, component patterns, responsive behavior, content requirements, and interaction logic before developers start committing time to implementation.
It also gives the development team something better than screenshots. Decisions about spacing, component states, reusable modules, content variation, and breakpoint behavior can be discussed before code makes every change more expensive.
No. Sometimes the smartest redesign is not a redesign. A site may look dated while still having good information architecture, useful content, strong search visibility, and a conversion path customers understand. In that situation, refreshing typography, spacing, navigation, mobile layouts, templates, and a few high-value pages may produce more value than tearing the whole website apart.
The buying trigger matters. Business owners discussing redesigns online repeatedly mention problems such as looking too small for larger prospects, poor mobile usability, weak leads despite traffic, dated positioning, difficult content updates, and a site that no longer represents the business. Those are better reasons to change a site than “it has been three years.”
A competent designer should be willing to say that twenty targeted fixes are enough. A redesign should solve a business or user problem, not manufacture one so the project can be larger.
A development handoff needs more than a link to attractive desktop screens. Developers need to understand how the design behaves when content, screen size, data, and user interaction change.
Useful deliverables can include organized Figma files, reusable components, typography and spacing rules, color tokens, desktop and mobile layouts, responsive guidance, hover and focus states, form behavior, empty or error states where relevant, asset exports, and annotations for interactions that cannot be understood from a static screen.
The handoff should also distinguish design responsibility from development responsibility. A discussion among UX practitioners about developers asking designers for finished HTML showed how quickly that boundary becomes messy when expectations were never agreed in advance. A clean handoff describes the intended interface precisely. It does not automatically mean the designer must write the production front end.
Templates have removed a lot of low-value production work. They have not removed the decisions that make a website useful.
A local business needing five straightforward pages may be perfectly well served by Squarespace, Wix, Shopify, Webflow, WordPress, or another established platform.
Starting with a proven template can be financially sensible. The designer’s value then shifts from drawing every component from scratch to choosing what to keep, what to change, how to structure the content, and how to stop the finished site looking like a template filled with company copy.
Builders become limiting when the business needs unusual journeys, a more distinctive brand system, complex content, stronger conversion logic, custom interactions, or a design that must scale across many page types. Even simple sites can suffer from poor hierarchy, clutter, inconsistent spacing, and weak mobile decisions if nobody is making those choices deliberately.
The practical question is not “custom or template?” It is how much original design thinking the business problem actually requires.
Web design costs depend heavily on how you hire and what you need designed. For freelance work, Upwork currently shows web designers commonly charging around 15-30 per hour. More specialized work can cost more, especially when the designer is handling custom layouts, complex responsive behavior, ecommerce, or UX-heavy projects. For a small business website, fixed project pricing may range from roughly 1,500-5,000, while ecommerce or more customized websites can move beyond that depending on scope.
Agencies sit in a different price bracket because the fee may include strategy, project management, UX, multiple designers, and broader delivery support. Clutch reports that many web design agencies charge around 100-149 per hour, with project costs varying significantly according to size and complexity.
Hiring someone full-time is a different calculation again. The US Bureau of Labor Statistics reports a median annual wage of $104,000 for web and digital interface designers as of May 2025. So the real comparison is not simply “which option is cheapest?” It is whether the business needs a one-time project, flexible freelance capacity, agency support, or someone working continuously inside the team.
Page count matters, but repeated pages are not the expensive part. Ten pages built from three established templates may require less design effort than a four-page site with complex interactions, unusual storytelling, custom illustration, and several conversion paths.
Complexity often hides in the system around the pages. Does the designer need to restructure the sitemap? Create a design system? Audit an existing site? Design ecommerce states? Build multilingual patterns? Account for logged-in users? Work around a legacy CMS? Produce prototypes? Create mobile states? Coordinate with copywriters and developers? Each question changes the scope.
Revision structure matters too. A project with one empowered decision-maker can move very differently from one where five executives independently review every screen. Cost is therefore partly a function of design difficulty and partly a function of decision-making complexity.
A freelancer often costs less when the requirement has a clean finish. One landing page, a homepage refresh, a small website, or a defined redesign can be bought as a project without carrying ongoing capacity after the work is complete.
The economics change when the website never really stops changing. Marketing teams may need new service pages, campaign pages, case-study templates, landing-page experiments, event pages, CRO changes, new sections, mobile refinements, and developer support every month. A freelancer has to retain availability, while the client may repeatedly pay the context cost of briefing different people.
A dedicated remote web designer makes more sense when that workload is continuous enough for retained brand, CMS, component, and conversion knowledge to matter. The financial comparison should include how often the business has to rebuild context, not merely the hourly rate on an invoice.
They are different amounts of work disguised by similar language. A visual redesign might involve page layouts, responsive states, and reusable components. A deeper UX engagement can add research, user journeys, information architecture, prototypes, testing, and design-system work. Full website delivery adds front-end development, CMS implementation, integrations, backend work, testing, deployment, analytics, performance work, and sometimes content migration.
Current market data shows how quickly those scopes diverge. Clutch reports that web design projects in its dataset generally sit below $10,000, while UX/UI projects commonly fall into the 10,000-49,999 bracket. Its web-development pricing data also shows that project totals can expand significantly once implementation complexity and longer delivery timelines are involved. The only sensible quote comparison is one where the deliverables are genuinely comparable.
Outsourcing makes sense when the business needs design capability but does not have enough consistent work, or the right mix of work, to justify building the entire function internally.
A company launching a new website every four years probably does not need a permanent senior web designer. A growing marketing team producing pages every week may need dedicated capacity but still prefer not to carry recruitment, payroll, infrastructure, and long-term employment overhead. Another business may already have internal designers but temporarily need additional support for a redesign or campaign surge.
Skill access matters as much as utilization. One project may need strong conversion design, another ecommerce experience, another WordPress familiarity, another complex responsive component system. Outsourcing works best when the model gives the company the right depth of skill without forcing it to permanently hire every specialist it may occasionally need.
Content is one of the biggest. A redesign gets approved, then the company discovers nobody has written the service pages, sourced usable photography, updated case studies, cleaned the product catalog, or decided what to do with hundreds of old URLs. The design team either waits or starts making expensive assumptions.
Development changes create another category. A seemingly simple design decision may require a new CMS component, paid plugin, additional integration, custom animation, or significant responsive work. Add stock assets, font licensing, accessibility remediation, analytics setup, testing, migration, redirects, hosting changes, and post-launch fixes, and the “design budget” can become only one part of the actual website cost.
Internal time belongs in the calculation too. Weekly review meetings involving six senior people are not free just because they do not appear on the agency invoice. Poorly structured approvals can become one of the most expensive parts of a redesign without anybody labeling them as a cost.
Start with what the website is supposed to accomplish. A lead-generation site might track qualified enquiries, form completion, booked meetings, page-to-contact conversion, and the proportion of visitors reaching high-intent pages. An ecommerce site has different signals: product discovery, add-to-cart behavior, checkout completion, average order value, and revenue per visitor.
Some returns are operational rather than immediately financial. A reusable page system can reduce the time marketing spends launching campaigns. Better navigation can reduce repetitive support questions. Cleaner CMS patterns can stop every new page from requiring a developer. A redesign that makes the company credible enough to support larger sales conversations may matter even if the homepage conversion rate barely moves.
Measure against a baseline whenever possible. Record conversion, engagement, mobile behavior, speed, search traffic, and lead quality before the work begins, then compare after launch and after the site has had enough time to stabilize. A redesigned website that merely looks newer is difficult to value. A website that removes measurable friction is much easier to defend.
The strongest case is usually not company size. It is how much the website influences trust, discovery, and sales. A consulting firm may need the site to make a high-value service understandable before a prospect books a call.
An ecommerce brand needs product discovery, mobile usability, and checkout confidence. A SaaS company may have to explain a complicated product in thirty seconds. A local service business needs visitors to understand where it operates, what it does, and how to contact it without hunting through the page.
The need becomes more serious when the website is actively costing the business something. Traffic arrives but does not convert. Sales teams avoid sending prospects to the site. Marketing cannot launch pages without developer support. Mobile visitors abandon key pages. The company has outgrown a five-year-old structure that still reflects what it used to sell. Those are much stronger hiring signals than simply wanting a more fashionable homepage.
A redesign makes sense when the underlying structure is causing problems that isolated fixes cannot solve. Suppose the navigation reflects an old service model, every page uses a different layout, the CMS makes simple updates painful, mobile behavior is inconsistent, and new campaigns have to be forced into page templates designed years ago.
Updating fonts and replacing the hero image may make the site look newer, but the underlying constraints remain. Incremental improvement is smarter when the architecture still works. A website with strong search visibility, useful content, good conversion paths, and a manageable CMS may need better typography, mobile layouts, component cleanup, or a few high-value page redesigns rather than a complete rebuild.
The decision should come from evidence. Analytics, user behavior, sales feedback, conversion performance, page maintenance problems, and technical limitations usually tell you whether the site needs surgery or rehabilitation.
An ecommerce visitor is constantly making micro-decisions. Do I trust this store? Is this the right product? Which variation should I choose? What will shipping cost? Can I return it? Is checkout going to be painful?
Design has to answer those questions without creating clutter. Product imagery, pricing, reviews, variants, delivery information, stock status, related products, filters, search, cart behavior, and checkout all compete for space. On mobile, those decisions happen inside an even tighter interface.
Imagine a fashion store with beautiful photography but filters hidden behind confusing controls, size information buried below the fold, and a sticky promotion covering part of the mobile screen. The site can look premium while making shopping harder.
Strong ecommerce design therefore pays close attention to product discovery and buying friction, not just aesthetics. The platform matters too, because Shopify, WooCommerce, and custom commerce systems impose different constraints on templates, checkout, apps, and product data.
A landing page usually performs better when every section helps answer one specific decision: “Is this relevant enough and credible enough for me to act?” That begins above the fold. If someone arrives from an ad promising outsourced bookkeeping and lands on a generic homepage talking about “transforming businesses,” the design has already created friction. The message, offer, proof, and call to action should continue the conversation that brought the visitor there.
The rest of the page needs sequencing. A high-intent visitor might need the problem, offer, outcome, proof, process, objections, and action in that order. Another campaign may need pricing or a demo much earlier. There is no universal twelve-section conversion template.
Design contributes through hierarchy, scanning, visual proof, form friction, mobile usability, and keeping secondary distractions under control. Conversion work gets weaker when “make the CTA bigger” replaces understanding why people are hesitating.
SaaS websites have an explanation problem. The product may be technically complex, but the visitor still needs to understand quickly who it is for, what changes after using it, and why this product deserves attention over dozens of alternatives.
That often means designing around product evidence rather than decorative graphics. Interface screenshots, short workflows, integrations, comparison tables, use cases, customer proof, security information, and pricing can be more persuasive than another abstract gradient.
The designer also needs to separate the marketing site from the product itself. The public website sells understanding and confidence. The application handles the deeper interaction. Trying to reproduce the entire product experience on the homepage usually creates noise. Good SaaS design also anticipates growth. A company may begin with one product and later add industries, integrations, enterprise pages, documentation, partner content, and multiple pricing tiers. Page systems that work only for the launch version become expensive surprisingly quickly.
SEO pages often fail visually because teams treat search content and design as competing priorities. The writer produces 2,000 words. The designer then tries to hide most of them so the page feels cleaner. A better approach is to design the information hierarchy around search intent. A service page may need a clear offer, capabilities, process, industries, pricing context, case studies, FAQs, comparison information, and supporting detail. That content can be organized into scannable sections rather than presented as one uninterrupted wall of text.
The designer also needs to preserve actual HTML content, heading hierarchy, internal links, and crawlable information instead of turning meaningful text into images or interaction patterns that make it unnecessarily difficult to access.
SEO should influence structure without dictating aesthetics. The page can still have strong visual pacing, proof, whitespace, and conversion paths. Search visibility gets people to the page. Design helps them understand what they found.
They do not need to be the developer, but they should understand the environment well enough to avoid designing something the platform handles badly. A Webflow site, for example, has a responsive system built around breakpoints and cascading styles.
Understanding how responsive breakpoints behave inside Webflow helps the designer create layouts that translate cleanly rather than handing developers a completely different composition for every screen width.
Shopify creates different constraints around product templates, collections, checkout, apps, and theme architecture. WordPress can vary enormously depending on the theme, builder, custom fields, and development setup. A designer who ignores all of that may produce an elegant concept whose implementation requires unnecessary custom work.
Platform knowledge should inform the design without allowing the CMS to dictate every creative decision. The sweet spot is knowing what is native, what is possible with reasonable effort, and what seemingly simple idea will create three weeks of development.
Start by identifying what already works before changing it. A redesign team should know which pages attract organic traffic, which URLs have backlinks, which pages convert, what internal links matter, and which content ranks for commercially useful searches. A page should not disappear simply because it looks old in the new sitemap.
URL changes need particular care. Google’s guidance for site moves and URL changes recommends mapping old URLs to their appropriate new destinations, using permanent redirects, testing the new site thoroughly, and monitoring Search Console after launch. Redirecting dozens of deleted pages to the homepage is not a proper migration strategy.
The same caution applies beyond rankings. Record conversion rates, form submissions, engagement, page speed, and important user journeys before launch. A redesigned website should not be declared successful because stakeholders like the new screenshots while organic traffic or qualified enquiries quietly fall.
A graphic designer normally creates compositions with relatively controlled boundaries. A brochure has pages. A poster has dimensions. A social graphic has an expected format. A website refuses to stay still. The same design has to survive a 27-inch monitor, a phone held vertically, longer headlines, translated copy, accessibility settings, dynamic CMS content, hover states, validation errors, and components that appear in combinations the designer may never have mocked up.
Web designers need to consider hierarchy, navigation, responsive behavior, interaction, performance implications, reusable components, and what happens when the content changes. A strong graphic designer can absolutely move into web design, especially with good typography and brand skills. The missing capability is not visual taste. It is understanding that a website is a responsive system rather than a sequence of fixed canvases.
If the problem is primarily how the website looks and communicates, a strong web designer may be enough. If nobody understands why users are getting lost, abandoning a journey, or failing to complete a complex task, deeper User Experience (UX) work becomes more valuable.
Consider a university website containing thousands of pages for students, parents, researchers, faculty, and applicants. The challenge is not simply redesigning prettier menus. The team may need research, interviews, card sorting, information architecture, journey mapping, prototypes, and usability testing before anybody should decide what the interface looks like.
A twenty-page marketing website rarely needs a separate UX department. A complex portal, marketplace, financial workflow, healthcare journey, or large information-heavy site might.
The distinction is useful because visual redesign is sometimes prescribed for problems that are actually structural. Changing the interface without understanding the behavior underneath can give the same confusing journey better typography.
A User Interface (UI) designer specializes in the visual and interactive system people operate: components, controls, states, hierarchy, spacing, typography, and consistency across an interface.
Web designers use many of those same skills, but their responsibility often extends further into marketing communication. They may work on storytelling, editorial layouts, campaign sections, service positioning, case studies, content hierarchy, and the visual expression of the brand across the website.
The distinction becomes clearer inside a software company. One designer may own the product interface containing tables, dashboards, forms, permissions, and complex application states. Another may design the marketing website used to explain and sell that product.
Small teams often combine both roles successfully. The risk appears when a company assumes that excellent product UI automatically means excellent marketing-web design, or vice versa. They require overlapping craft but different instincts.
The designer should specify the experience clearly enough that development does not become an exercise in guessing. The developer should decide how to implement that experience reliably in code.
For a pricing card, the designer may define hierarchy, typography, spacing, responsive behavior, hover and focus states, a recommended option, and what happens when the plan name becomes longer. The developer decides the HTML structure, CSS implementation, JavaScript behavior where required, performance considerations, and how the component connects to the production system.
The handoff should still be collaborative. Developers often spot technical implications designers have missed. Designers often catch implementation changes that damage hierarchy or accessibility. The strongest teams review work during development rather than throwing Figma files over a wall and meeting again at launch.
A skilled builder expert can be exactly the right hire when the visual direction is established and the main task is implementation. For example, a business may already have approved Figma designs and simply need someone who understands Webflow deeply enough to build responsive components, CMS collections, animations, and reusable templates. Hiring another designer to rethink work that is already settled adds little value.
The situation reverses when the business has a tool but no design logic. Knowing how to operate Elementor does not automatically answer what belongs above the fold, why the navigation is confusing, whether the page hierarchy supports conversion, or how the identity should translate into digital layouts.
Tools remove production friction. They do not automatically supply judgment. The company needs to determine whether its problem is building the design or deciding what should be built.
Brand design establishes the visual language. Web design makes that language behave inside an interactive environment.A brand system may define typography, colors, photography, illustration, logo treatment, graphic devices, and overall visual character.
The website then has to turn those ingredients into navigation, cards, forms, page templates, responsive layouts, calls to action, content hierarchy, and hundreds of real interface decisions. Problems arise when brand guidelines were created entirely for print or presentation use.
A beautiful display font may become unreadable at small sizes. A wide color palette may fail accessibility contrast. A graphic device may dominate mobile screens. The web designer needs enough judgment to preserve the brand’s character without mechanically reproducing every brand rule. The website should feel unmistakably like the brand. It should not behave like a PDF that happened to become clickable.
Sometimes one person can cover several areas. Rarely can one person cover all of them equally well. Take a 40-page B2B website redesign. The copywriter may need to rethink the proposition and service messaging. SEO may determine which existing pages and search demand must be preserved. The designer creates the hierarchy, page system, conversion flow, and responsive interface. Development turns it into a functioning CMS and production website. None of those disciplines can simply wait until the others finish because decisions overlap.
A five-page local business site is different. A strong multidisciplinary designer working with an established platform and decent client-supplied content may handle most of the requirements without building a five-person team.
Start with the gaps, not the organization chart. If the content is weak, prettier screens will not fix it. If the design is strong but the build is poor, the launched site will still fail. If traffic disappears during migration, neither design nor development alone can repair the business impact. The right team is the smallest combination of skills that covers the actual risk.
Start by ignoring the polished mockups for a moment. A website shown inside a MacBook frame tells you very little about whether the designer understood the business problem, created a usable information hierarchy, handled responsive behavior properly, or produced something developers could actually build. Look for case studies that explain what was wrong before the redesign, what decisions were made, and how the finished system addressed those problems.
Then examine the work at page level rather than judging only the homepage. How does a service page handle dense content? What happens to comparison tables on mobile? Are forms, navigation, cards, testimonials, FAQs, and calls to action designed consistently? Does the portfolio show responsive states or only large desktop canvases? A designer who has thought through real websites will usually have evidence beyond dramatic hero sections.
The strongest portfolios also reveal restraint. Every site should not use the same oversized headline, floating cards, gradients, rounded buttons, and scroll animation regardless of industry. Look for signs that the designer changed the visual language, content density, interaction model, and conversion approach according to the business rather than applying one personal style to every client.
A web designer does not need to be a production front-end developer, but they should understand the medium they are designing for. Responsive layouts, CSS-style layout logic, grids, breakpoints, flexible containers, component states, content overflow, image behavior, and browser constraints should influence the design before anything reaches development.
Design-system thinking matters too. Instead of creating ten slightly different buttons across ten screens, a strong designer thinks in reusable components, variants, spacing rules, typography scales, color roles, and repeatable patterns. Modern Figma workflows reinforce this through components, variables, auto layout, and reusable values for things such as spacing, color, typography, and responsive behavior. Figma’s guidance on structuring design files for implementation specifically recommends components, variables, meaningful naming, auto layout, and annotations so designs translate more predictably into code.
The technical bar should still serve design judgment. Knowing auto layout is not the same as knowing why a pricing page is confusing. Strong web designers combine platform literacy with typography, hierarchy, accessibility, content structure, conversion thinking, and enough development awareness to know when a visually attractive decision will become fragile or unnecessarily expensive in production.
Ask them to explain a website decision they changed after learning more about the users or business. That gets much closer to real design ability than asking whether they know Figma. A good answer might involve simplifying navigation after analytics showed visitors missing an important service, changing a mobile layout because the desktop hierarchy collapsed badly, or reducing the number of calls to action once the primary journey became clearer.
Then test production thinking. Ask how they handle responsive states that were not explicitly mocked up, what happens when CMS content is much longer than the sample copy, how they communicate interaction behavior to developers, and how they manage design changes once development has begun. A designer who thinks only in screenshots will often struggle once the conversation moves into states, constraints, and systems.
Finally, ask how they decide when not to redesign something. Experienced designers should be able to protect an existing pattern that already works instead of changing it to demonstrate creativity. Websites accumulate user familiarity, SEO value, development investment, and conversion history. Good design judgment includes knowing what deserves to remain untouched.
A conversion-focused page should make the next decision easier, not simply make the call-to-action button brighter. Start by tracing the visitor’s likely questions. What is being offered? Is it relevant to me? Why should I believe you? What will happen if I continue? What does it cost or require? What risk am I taking? The page structure should answer those questions in an order that matches the buying situation.
Consider a paid-search landing page for an accounting service. If the ad promises outsourced bookkeeping for US businesses but the landing page begins with a generic company history, shows no relevant proof, and asks visitors to “Explore Our Solutions,” the visual design may be polished while the conversion path is weak. A stronger page might establish the specific service, intended client, evidence, process, key objections, and one primary action before introducing broader company information.
Measurement should follow. Designers do not get to declare a page high-converting simply because it follows familiar CRO patterns. Form starts, completions, CTA interaction, scroll behavior, lead quality, and experiment results can reveal whether the hierarchy actually improved decision-making. Conversion design is an evidence loop, not a visual style.
Responsive design is fundamental because websites no longer have one canonical canvas. A layout may need to behave sensibly across a 1440-pixel desktop, a narrow laptop, a tablet held in either orientation, and dozens of mobile widths without requiring an independently designed screen for each device.
The difficult part is not shrinking elements. It is deciding how the hierarchy changes when available space collapses. A four-column comparison may become horizontally scrollable, stacked, or reformatted. A complex desktop navigation may need an entirely different interaction model on mobile. Decorative imagery may disappear. Typography may use fluid scaling. Buttons that sit beside each other on the desktop may need to stack while preserving the correct action priority.
A useful portfolio review therefore asks to see intermediate and narrow states, not just one desktop frame and one idealized iPhone frame. Designers should understand how containers, breakpoints, wrapping, minimum widths, content length, and reusable components affect the spaces between those two examples. Responsive expertise lives in those transitions.
Do not ask only whether the designer “knows WCAG.” Give them an actual interface and ask what they would inspect. Strong candidates should notice color contrast, text size, keyboard focus, form labels, error states, target sizes, semantic hierarchy, interaction cues that rely only on color, and whether important content disappears for people who cannot use a mouse or see an image.
Accessibility also needs to appear in component design. A dropdown requires more thought than its closed visual state. What does keyboard focus look like? Can the menu be operated without a mouse? Is the focused item visible if a sticky element overlaps it? WCAG 2.2 specifically includes requirements around keyboard focus not being obscured, alongside the broader principles of perceivable, operable, understandable, and robust content.
W3C’s WCAG 2.2 guidance is the appropriate baseline rather than treating accessibility as an optional QA check after development.
The designer does not carry accessibility alone. Semantic HTML, ARIA use where appropriate, keyboard implementation, screen-reader behavior, and other technical details involve development too. The designer’s responsibility is to avoid creating inaccessible decisions before the developer even receives the file.
Look at the design file. It often reveals the answer before anyone describes their process.
A production-ready file should have recognizable components, sensible variants, consistent spacing and typography, meaningful names, reusable styles or variables, and enough annotation that developers do not need a meeting to understand every interaction. Figma’s own handoff guidance recommends documenting component usage, variants and states, using descriptive styles, and organizing files so developers can locate the correct source of truth.
Collaboration matters beyond file hygiene. Good designers involve developers when a concept has technical consequences, review the build before launch, and distinguish between a genuine implementation limitation and simple resistance to doing something unfamiliar. Good developers, in return, should not silently simplify the design because a detail is inconvenient. Mature handoff is a conversation between two disciplines, not a transfer ceremony.
Because a website is a system, while many projects are managed as a collection of pages. Teams approve a homepage, then a service page, then an about page, but nobody establishes how typography, components, page hierarchy, spacing, CMS content, responsive behavior, and interaction patterns work together across the entire site.
Content frequently exposes the weakness. A designer builds elegant layouts around placeholder copy, then real headlines are twice as long, case studies contain different amounts of information, and service pages require sections nobody planned for. Development starts patching exceptions. Three months later, the system contains six versions of the same card because the original design never accounted for variation.
Projects also fail when the business problem remains vague. “Make it modern” is not enough direction for a major redesign. A team needs to know whether the site is struggling with credibility, navigation, conversion, positioning, mobile usability, content scale, CMS maintainability, or something else. Otherwise, visual improvement becomes the only measurable outcome.
A website can win aesthetic approval while being slow, confusing, inaccessible, or difficult to act on. Large video backgrounds, complex animation, oversized imagery, custom fonts, and heavy JavaScript can create striking presentations while increasing load time and interaction cost if implementation is careless.
Performance is not merely a developer concern because design choices create much of the workload developers later have to optimize. Google’s Core Web Vitals focus on loading, interactivity, and visual stability through metrics such as Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). A designer who repeatedly specifies huge media assets, unstable content regions, or interaction-heavy components should understand that those choices can have measurable consequences once the page reaches production.
There is also cognitive performance. A visitor should not need to admire the site before understanding it. If animation delays access to content, typography sacrifices readability, navigation hides common tasks, or visual novelty overwhelms the offer, the design is working against the business. Attention is useful only when it helps people move forward.
The expensive surprises usually begin before anyone opens Figma. The business thinks it is redesigning 25 pages, then discovers 600 indexed URLs, three legacy forms, dozens of downloadable assets, multilingual content, undocumented integrations, inconsistent CMS templates, and a sales team depending on pages nobody included in the original scope.
Content creates another major delay. Teams often approve layout concepts using temporary copy and assume final content can be inserted later. Once real copy arrives, sections change length, new proof points appear, old pages need consolidation, SEO stakeholders request additional content, and designers begin reopening layouts that were supposedly complete.
Approval structure can compound everything. If stakeholders enter at different stages, previously approved decisions get reopened. The strongest projects define scope, content ownership, migration responsibilities, decision-makers, page types, review stages, and change-control rules early enough that new requirements are recognized as new scope rather than quietly absorbed.
Feedback becomes endless when nobody knows what an approved decision actually means. One stakeholder comments on typography, another rewrites the headline, a third changes the page objective, and somebody joining the project three weeks later questions the entire navigation. The designer is revising several different problems simultaneously.
A better process moves from large decisions to small ones. Agree on sitemap and page hierarchy before debating button styles. Approve a representative page system before designing forty pages. Resolve the design direction before polishing interactions. Once a decision is approved, reopening it should require a material reason rather than a new preference.
Feedback should also describe the problem rather than prescribe arbitrary fixes. “The enterprise proof is too easy to miss” gives the designer something meaningful to solve. “Move this box up 40 pixels and make it blue” reduces the process to production. Revision discipline is partly about fewer rounds, but more importantly about making each round operate at the correct level.
Maturity is visible in how few important decisions are left implicit. The team knows the page architecture, component system, content requirements, responsive rules, accessibility expectations, CMS constraints, and development responsibilities before production becomes expensive.
Design files behave like systems rather than image boards. Components have defined variants. Spacing and typography use consistent values. Repeated patterns are reusable. States such as hover, focus, selected, disabled, loading, success, and error are considered where relevant. Modern Figma workflows support this through variables and component structures that allow design values to map more cleanly to implementation rather than hardcoding each screen independently.
A mature process also includes QA after handoff. Designers review staging builds, compare responsive behavior, check whether components were implemented consistently, and catch visual or interaction problems before launch. The design team’s responsibility does not end the moment a developer opens Dev Mode.
Give each decision a clear owner. Large stakeholder groups can contribute context, but requiring unanimous approval from ten people usually turns design into compromise. One accountable owner should consolidate feedback and resolve conflicts before comments reach the design team.
The review environment should match the decision being made. Wireframes are for structure, not font critique. Visual concepts are for design direction, not rewriting every paragraph. Responsive reviews should focus on behavior across widths. Staging review should catch implementation and content issues rather than restart the design strategy.
A simple approval trail also protects the timeline. When navigation, homepage direction, and core components have been approved, those decisions should be recorded. If leadership later decides to reopen them, the team can assess the real schedule and budget impact instead of pretending the change is a routine revision.
For most web design work, location is rarely the limiting factor. Research, wireframes, Figma design, prototypes, design systems, content reviews, developer handoff, staging QA, and stakeholder presentations all work naturally through digital collaboration.
What remote designers need is access to context. If they receive isolated tickets saying “design a landing page” without knowing the campaign, audience, existing components, brand constraints, analytics, or previous experiments, quality will drop. The same problem would affect an in-house designer sitting five desks away if the organization withheld the same information.
Remote work becomes particularly effective when the designer stays with the product long enough to accumulate context. Knowing which templates exist, how developers build components, which stakeholders approve work, what has already been tested, and where the website historically struggles reduces unnecessary discovery on every request.
A company redesigning its site once every four years may be better served by a project freelancer or agency. A marketing team publishing campaigns, service pages, experiments, case studies, product launches, and site improvements every month has a fundamentally different requirement.
Ongoing work benefits from continuity because web design accumulates context. The designer learns the design system, CMS, responsive patterns, conversion history, approved components, developer constraints, and brand nuances. That makes the tenth page faster and more consistent than the first rather than treating every request as a new project.
A dedicated model becomes useful when the work is predictable enough to keep someone meaningfully occupied. It gives the client direct control over priorities while preserving the same designer’s knowledge over time. The economic advantage comes from retained context and available capacity, not simply from comparing one hourly rate with another.
Start by making the company, not an individual designer, the owner of critical accounts. Figma workspaces, CMS administration, domains, analytics, tag-management accounts, hosting, repositories, paid plugins, stock libraries, and password-management systems should not exist solely under a freelancer’s personal email address.
Access should follow responsibility. A designer who only needs Figma and staging access does not automatically need production database credentials or domain control. Multifactor authentication, role-based permissions, managed accounts, and shared password systems reduce the habit of passing sensitive credentials through email or chat.
Offboarding needs the same discipline as onboarding. Remove accounts, transfer file ownership, confirm source files and licensed assets are stored centrally, rotate credentials where necessary, and document anything the next designer or developer will need. A company should be able to replace a vendor without discovering that its website, design system, or brand files effectively left with them.
One experienced designer can handle a surprising amount when the website has a coherent scope and supporting skills already exist elsewhere. A strong individual may own wireframes, responsive page design, component creation, prototypes, and developer collaboration for a substantial marketing site.
The constraint appears when several streams need to move simultaneously. A large redesign may require UX research, information architecture, a design system, ecommerce or SaaS expertise, illustration, motion, accessibility review, and dozens of pages being produced while development has already started. One person can become the dependency through which every decision has to pass.
Team size should therefore follow concurrency and specialization rather than page count. A 100-page site built from six well-designed templates may not require six designers. A ten-page product site with complex interactive storytelling, multiple user journeys, and an aggressive launch schedule might.
Virtual Employee can provide dedicated web designers who work as an extension of the client’s existing marketing, product, or development team rather than treating every request as an unrelated project. That structure suits companies with recurring work such as landing pages, service pages, campaign assets, website updates, responsive improvements, conversion experiments, and new page templates.
The practical advantage is continuity. A dedicated designer can learn the company’s brand system, CMS limitations, component library, development workflow, approval process, and previous website decisions. Over time, less effort goes into re-briefing the same context and more goes into producing and improving the work itself.
Companies can use dedicated web design support alongside internal developers, copywriters, SEO teams, or marketing teams rather than replacing those functions. For businesses with a steady web-design backlog, that gives them continuing design capacity without having to rebuild the working relationship for every new page.
Still Have a Question?
Talk to someone who has solved this for 4,500+ global clients, not a chatbot.
Get a Quick Answer