SEO for developers
Where marketing and code finally meet
If you’ve ever built a website and heard someone say, “We’ll handle the SEO later,” you already know how that ends. Later never really comes. SEO isn’t a last-minute checklist after launch. It starts in your code, in how your pages are structured, and in how your data is served to both humans and search engines.
Developers and marketers often live on different planets. Marketers talk about visibility, keywords, and conversions. Developers talk about bundles, SSR, and database queries. But when those worlds overlap, great things happen. Websites load faster, rank higher, and bring in more visitors without extra ads or tricks.
SEO is not about gaming Google. It’s about making sure your site can be understood. And when the code is clean, structured, and fast, everyone wins.
Why SEO matters to developers
Most developers care about performance, not page rank. But here’s the catch: both are connected. A slow page can drop your search ranking just like a bad keyword. A missing title tag or wrongly implemented redirect can make a whole product page disappear from Google overnight.
Good SEO is simply good engineering. It’s logical structure, readable URLs, and a website that doesn’t confuse crawlers or users. A well-coded site makes the marketer’s job easier, and your own life easier when you need to debug or scale.
The basic stuff (that’s worth knowing anyway)
Let’s start with a few basic ideas. Understanding these will already put you ahead of many developers who think SEO is just “meta tags and blog posts.”
Crawling is how search engines discover pages on your website. They follow links and read your sitemap to find what exists. If your content is hidden behind authentication, JavaScript routing, or infinite scroll, it might never be crawled.
Indexing means the search engine actually saves and lists your page in its database. A crawled page is not automatically indexed. If Google finds errors, duplicated content, or thin content, it might skip it.
Rendering is what happens after crawling. Google tries to see your page like a user would. For a static site, that’s easy. For a React or Svelte app that loads content with API calls, this can be tricky. Sometimes Google doesn’t wait long enough for your JavaScript to finish.
On-page SEO is what users and search engines both see: your title tags, descriptions, headers, and content. This is the layer marketers tweak the most.
Technical SEO is everything that supports it under the hood: sitemaps, redirects, schemas, structured data, canonical URLs, and performance. This is where developers have the biggest impact.
So if you ever wondered where marketing meets code, it’s right here: between on-page and technical SEO.
And there’s now one more reason to care: large language models like ChatGPT, Gemini, and Perplexity increasingly use the web as a base for their answers. When your website ranks high and has clean, structured data, it’s not just Google or Bing that notices. LLMs also pull from those same pages when they generate answers. Better SEO means your brand is more likely to be mentioned, quoted, or linked when people use AI to search.
Eight practical things developers can do for SEO
1. Make it fast
A fast site doesn’t only make visitors happy, it directly affects rankings. Google tracks loading performance through metrics like LCP (Largest Contentful Paint), FID (First Input Delay), and CLS (Cumulative Layout Shift). These sound fancy, but they’re really about one thing: how quickly users can see and interact with your page.
Compress your images before upload, not after. Use WebP or AVIF formats when you can. Minify your CSS and JS. Cache aggressively. Serve static assets via CDN. Lazy load heavy components like maps or carousels only when visible. The goal is simple: deliver the first readable content in less than 2 seconds. It’s doable, even on a small budget, if you care enough to measure it.
2. Use proper headings
Your <h1> is the title of the story. There should only be one per page. Then come your <h2> and <h3> elements for structure. Think of it as a family tree: clear parents, children, and siblings.
Headings are not a styling choice. They tell Google and users what’s important. A blog post with ten <h1> tags looks like ten competing topics. Use headings logically, not visually. Style them in CSS instead of abusing hierarchy for font size. When done right, your content becomes easier to scan and much easier to index.
3. Don’t block crawlers by accident
Many websites never get indexed simply because someone forgot to remove noindex or disallowed / in robots.txt. It happens more than you think. Always check these before launch.
If you use frameworks like Next.js or SvelteKit, make sure dynamic routes like /blog/[slug] are actually discoverable via a sitemap or server-side rendering. Don’t assume Google will magically figure it out. It won’t. Also, remember that search engines can’t log in, so anything behind authentication or paywalls is off limits.
4. Generate clean URLs
URLs are like street names. If they’re short and logical, people and crawlers both understand them. /hotels/bangkok says everything. /index.php?id=82&ref=abc says nothing.
Use hyphens instead of underscores. Keep URLs lowercase. Avoid unnecessary parameters unless they’re essential for filtering. Once you set a structure, don’t change it too often. If you must, redirect properly (see next point). Consistency builds trust, for users and for crawlers.
5. Handle redirects properly
Redirects are like moving houses. When you change an address, you leave a note at the old one. That’s what a 301 redirect does: it tells search engines, “Hey, this content lives over there now.” It helps users land on the right page and keeps your SEO power from getting lost.
But here’s the thing, most people overcomplicate it. Avoid creating redirect chains. Don’t send people through three URLs before they land on the right one. Just go from old to new in one step. And if you’re doing a redesign, keep a list of your old URLs. Map them to the new ones. It takes an hour but saves you months of lost traffic.
6. Make it crawlable
Modern SPAs are great for users, but tough for crawlers. If your content only appears after JavaScript renders, Google might miss it entirely. Server-side rendering (SSR) or static prerendering solves that. It gives search engines an already-built HTML version to read.
If SSR isn’t possible, use prerendering services or export your pages statically. Another trick is to ensure your critical content appears in the initial HTML before hydration. Think about crawlers as text-only browsers. If they can’t see your data without scripts, you’re invisible.
7. Add metadata and structured data
Your <title> and <meta description> are the headlines people see in search results. They don’t just tell Google what’s on your page; they also convince users to click. Keep them concise and clear.
Beyond that, structured data (JSON-LD) helps search engines understand context. For example, marking up your blog post with @type: "Article" or your product with @type: "Product" can get you rich snippets — the nice boxes with reviews, images, and prices. It’s basically giving search engines extra clues, and they reward you for it.
8. Build for users, not just crawlers
It’s easy to get lost in the technical side, but SEO is still about humans. A readable layout, simple navigation, and responsive design are more valuable than any keyword stuffing.
If users bounce because the font is too small or the mobile view is broken, your rankings drop. Search engines measure engagement indirectly. Make content scannable, add internal links where it makes sense, and test your site on actual phones, not just in dev tools. The better the experience, the more people stay, share, and link.
And that’s real SEO.
When marketing and dev actually work together
The best results happen when marketing and development collaborate early. Before you decide how to structure routes, how to name folders, or how to serve content, talk about SEO. Agree on URL patterns, language handling, and canonical logic before the code is live. When devs understand SEO, marketing stops being a mysterious afterthought. It becomes teamwork. And that’s when websites start performing: not just technically, but in the real world, with actual visitors.
In short
SEO isn’t a layer you add on top of a finished project, it’s something you build in from day one. It’s not about pleasing Google, it’s about helping people find what they’re looking for.
And when the code and the content play well together, you’ll spend less time fixing, more time building, and your websites will finally get the traffic they deserve.
With We Do Dev Work, you don’t have to figure it out alone. We help you combine clean, structured code with SEO best practices so your site ranks, performs, and delivers results.
Start building websites that work for both users and search engines, reach out today and see what We Do Dev Work can do for your project.
