Crawl architecture
URL patterns, internal links, XML sitemaps, canonical rules, redirects, filters, pagination, and crawl-budget control.
Custom websites do not behave like ready-made templates. They often include dynamic routes, private dashboards, API-driven content, JavaScript rendering, filters, search pages, and unique business logic. This specialty focuses on making every important URL discoverable, renderable, fast, structured, and commercially useful so search engines can understand the website exactly as users experience it.
Custom routing, filters, and generated URLs can waste crawl budget or hide important pages from search engines.
JavaScript, APIs, and conditional templates need careful handling so Google can read the final content.
Slow queries, heavy scripts, and unoptimized assets can limit rankings even when the content is strong.
Custom websites often contain login pages, duplicated filter states, internal search results, and parameter URLs. I separate pages that should rank from pages that must stay blocked or canonicalized.
When pages are generated from databases, every template needs reliable titles, descriptions, Open Graph data, canonical URLs, breadcrumbs, and structured data rules.
A strong custom site still struggles if money pages, feature pages, or location pages are buried too deep or disconnected from the main navigation and content hubs.
A full review of routing, status codes, canonical logic, robots rules, XML sitemaps, rendered HTML, templates, pagination, filters, and crawl paths to find what blocks visibility.
Design which pages should be indexed, which should be blocked, which should canonicalize, and how search engines move from navigation to commercial pages without wasting crawl budget.
Check whether key content, links, metadata, schema, and product or service data are available in the rendered page and fix client-side issues that hide content from Google.
Prioritize performance fixes that affect SEO and conversions: LCP, INP, CLS, image delivery, scripts, caching, database bottlenecks, server response, and mobile experience.
Create rules for titles, descriptions, Open Graph, Twitter cards, breadcrumbs, organization, service, FAQ, product, and article schema so new pages launch SEO-ready.
Turn recommendations into clear developer tasks, acceptance criteria, QA checks, and release priorities so SEO fixes are implemented correctly and do not break after deployment.
I review the stack, CMS or custom admin, routes, templates, sitemaps, robots rules, Search Console data, analytics, server behavior, and staging access to understand how the site is generated.
I test how search engines discover URLs, what HTML they receive, what content is delayed by JavaScript, which pages are duplicated, blocked, canonicalized, thin, or missing metadata.
I translate findings into priorities: URL rules, indexation policy, internal links, schema templates, metadata logic, page hierarchy, performance tasks, and exact developer acceptance criteria.
I work with implementation teams to validate fixes before and after release, checking rendered output, redirects, canonical tags, status codes, schema, page speed, and mobile behavior.
After launch, I monitor indexing, crawl errors, Core Web Vitals, rankings, impressions, clicks, landing page performance, and commercial pages to refine the SEO roadmap.
Recommendations are written with the codebase in mind, so developers receive clear tasks instead of generic advice that cannot be implemented safely.
The work separates valuable landing pages from duplicate, filtered, private, thin, or parameter-based URLs so Google spends more attention on pages that can rank and convert.
Instead of editing every page manually, I help create rules that generate useful titles, descriptions, canonicals, breadcrumbs, and schema for new pages automatically.
Speed recommendations focus on ranking and business impact: Core Web Vitals, server response, JavaScript cost, image delivery, mobile usability, and high-value pages.
Every technical SEO fix is validated after implementation so redirects, rendered HTML, schema, status codes, canonical tags, and noindex rules do not break in production.
I review URL patterns, dynamic routes, filters, search pages, and JavaScript-only paths to decide what deserves indexing and what should be excluded, then define crawl and internal linking rules.
I test rendered HTML, API content, interaction-loaded data, canonicals, robots directives, sitemaps, and noindex rules to ensure important pages are fully visible to search engines.
I translate SEO requirements into reusable template rules for dynamic titles, meta descriptions, headings, schema, breadcrumbs, pagination, hreflang where needed, and correct error handling.
I identify the real impact of images, scripts, fonts, queries, caching, and JavaScript size on Core Web Vitals, then prioritize fixes by organic and conversion impact.
Before and after every release, I verify URLs, status codes, sitemaps, redirects, 404 and 500 errors, Search Console signals, and crawl behavior so updates do not damage organic growth.
I track technical, content, and business signals together: crawl efficiency, indexed pages, Core Web Vitals, structured data coverage, organic clicks, qualified leads, and revenue pages gaining visibility.
A complete technical audit tailored to the website architecture, programming stack, rendering model, and page-generation logic.
The target is zero priority pages without a clear indexation decision, metadata plan, and measurable organic-search purpose.
Target coverage for priority page templates with validated metadata, structured data, internal links, and indexation rules.
Target share of useful crawl activity directed toward indexable, valuable pages instead of duplicate parameters and low-value URLs.
| Criteria | Mohamed Yahia | General Freelancer |
|---|---|---|
| Crawl and indexation |
A clear URL map, canonical and noindex rules, clean sitemaps, and crawl priority focused on pages that can generate results. |
Dynamic URLs without an indexation decision, allowing weak pages to appear while important pages may remain undiscovered. |
| JavaScript rendering |
Rendered HTML is validated and loading behavior is improved so text, links, and structured data are visible to search engines. |
Important content appears to users but may be absent for search engines because of delayed loading or full API dependency. |
| Metadata and structured data |
Scalable rules generate unique metadata and schema for every page type, with Rich Results validation before release. |
Repeated or missing titles and descriptions, with inconsistent or absent schema across dynamic templates. |
| Performance and Core Web Vitals |
Performance work is prioritized by organic and conversion impact, with before-and-after measurement for every major fix. |
Images, scripts, queries, and layout shifts hurt LCP, INP, and CLS without a clear order of priorities. |
| Developer collaboration |
Clear development requirements, implementation examples, priorities, acceptance criteria, and QA after deployment. |
Generic recommendations that are difficult to convert into actionable tickets inside the development cycle. |
| Measurement and growth |
Dashboards connect indexation, crawl data, performance, keywords, landing pages, and conversions for continuous decisions. |
Tracking visits and rankings alone without connecting technical problems to landing pages and business outcomes. |
Custom website SEO aligns code, rendering, information architecture, and content so every valuable page can be discovered, understood, indexed, and measured by search engines.
URL patterns, internal links, XML sitemaps, canonical rules, redirects, filters, pagination, and crawl-budget control.
Server and client rendering, API-loaded content, JavaScript navigation, hydration, robots directives, and rendered HTML validation.
Dynamic metadata, headings, schema, breadcrumbs, image attributes, hreflang, and reusable rules for every page template.
Core Web Vitals, image delivery, script execution, caching, fonts, queries, third-party code, and server response time.
Pre-launch acceptance checks, staging reviews, redirect mapping, error monitoring, and regression testing after deployment.
Search Console, analytics, landing-page performance, conversion events, log insights, and clear technical KPIs.
This service is designed for websites whose search performance depends on custom routes, dynamic data, application logic, or JavaScript rendering.
Marketing pages, public product views, documentation, integration directories, use cases, and programmatic landing pages.
Large dynamic inventories, profiles, locations, filters, category combinations, faceted navigation, and user-generated pages.
Next.js, React, Vue, Nuxt, Node.js, Laravel, API-first builds, headless CMS platforms, and hybrid rendering systems.
The work is converted into an implementation system your technical and marketing teams can use, verify, and measure.
Yes. Custom-built websites require deeper understanding of code, URL generation, JavaScript, APIs, templates, and deployment. Optimization depends on technical decisions implemented inside the website architecture, not only ready-made plugins.
Code access or direct developer communication is preferred, but a comprehensive external audit can start the process. Issues are then translated into clear requirements for canonicals, schema, sitemaps, rendering, redirects, and performance.
Yes. Each stack is handled according to its rendering, routing, and page-generation model. React and Next.js require rendering and hydration checks, while Laravel or Node.js projects need scalable routes, templates, caching, and structured data.
Technical improvements can become visible within weeks when crawl and indexation blockers are resolved. Stable keyword and traffic growth commonly takes three to six months depending on competition, content depth, and implementation speed.
Yes. Performance is connected to SEO and user experience. LCP, INP, and CLS are analyzed, then improvements to images, scripts, caching, fonts, and queries are prioritized by their real impact.
Yes. The deliverable is more than a general report. Recommendations are converted into clear development tasks with priority, rationale, acceptance criteria, verification steps, and post-implementation review when needed.
In custom websites, SEO is not an afterthought added on top of the design. It must be part of routing, rendering, performance, schema, internal links, and the way business pages are generated.
For custom websites, organic visibility depends not only on content but on how search engines see routes, templates, data, rendering, and speed. The work starts with technical engineering, then expands into content and growth.
Should it be indexed, consolidated, excluded, or canonicalized? Clear decisions prevent crawl waste and strengthen the pages that deserve to compete.
SEO is treated as part of the development lifecycle through clear requirements, practical examples, acceptance tests, and post-release validation, so recommendations produce measurable impact.
After fixes are released, measurement answers what was indexed, what improved, where crawl is leaking, and which pages need more content, authority, links, or performance work.
Share your custom website, staging link, or technical stack and I will identify the SEO issues blocking crawlability, indexation, performance, and conversions.
Get Started