Dwi Yanti Delete SEO Plugin & Code: What SERP Data Told Me

The Hypothesis

SEO plugins are written for everybody. Code written for everybody is optimized for nobody. What happens when you strip them out and write the exact same SEO logic yourself — but only the parts you actually need?

This experiment started not from theory but from frustration. I was building the WordPress theme for Dwi Yanti SEO Specialist from scratch — pure hand-coded PHP, no template, no page builder. When I looked at what Yoast and RankMath were actually outputting into the HTML head, I'm realized something: it was all reproducible. Every tag, every structured data block, every canonical — it was just PHP conditionals and wp_head hooks.

So I made a decision with SEO Strategy: do it myself. And then track what Google did in response.

What Plugins Actually Do (That You Can Replicate)

Before the experiment, I audited exactly what both Yoast SEO and RankMath were generating in the HTML source of a standard WordPress site. The output breaks down into six functional categories:

These results were observed directly on Dwi Yanti, where plugin-based SEO was replaced entirely with custom code.

Every single function is reproducible. None of it requires a plugin. The plugin just provides a UI for non-coders to configure these outputs. If you can write PHP, the UI is unnecessary overhead.

What Plugins Add That You Don't Need

Here is what I found in the page source after auditing a plugin-enabled WordPress installation on Dwi Yanti’s website — outputs that were loading on every page, contributing nothing to SEO:

• Plugin admin bar UI assets loaded on frontend (CSS + JS)
• Multiple preload directives for plugin-specific resources
• Redundant Open Graph tags overlapping with theme output
• Schema markup for post types irrelevant to the site's content type
• Database queries on every page load to check plugin settings
• JavaScript handles registered but never used on most pages

None of these help rankings, bad SEO Strategist approach. All of them add weight. And in a world where Core Web Vitals are a ranking factor, every unnecessary HTTP request and every additional database query costs you something.

How I Replaced the Plugin: The Code Architecture

Everything lives in functions.php. Here is the logical structure I built, in the order of implementation:

remove_theme_support('title-tag');

add_action('wp_head', 'dw_custom_title_tag', 1);
function dw_custom_title_tag() {
  if (is_single() || is_page()) {
    $title = get_the_title() . ' — Dwi Yanti';
  } elseif (is_archive()) {
    $title = single_cat_title('', false) . ' — SEO Insights';
  } elseif (is_home()) {
    $title = 'Technical SEO Specialist & Strategist — Dwi Yanti';
  } else {
    $title = get_bloginfo('name');
  }
  echo '<title>' . esc_html($title) . '</title>' . "\n";
}

add_action('wp_head', 'dw_canonical_url', 2);
function dw_canonical_url() {
  if (is_singular()) {
    $canonical = get_permalink();
  } elseif (is_home() && !is_paged()) {
    $canonical = home_url('/blog/');
  } elseif (is_category() && !is_paged()) {
    $canonical = get_category_link(get_queried_object_id());
  } elseif (is_paged()) {
    $canonical = get_pagenum_link(get_query_var('paged'));
  } else {
    $canonical = home_url($_SERVER['REQUEST_URI']);
  }
  echo '<link rel="canonical" href="' . esc_url($canonical) . '" />' . "\n";
}

add_filter('wp_robots', 'dw_custom_robots');
function dw_custom_robots($robots) {
  if (is_category() && is_paged() && get_query_var('paged') > 2) {
    $robots['noindex'] = true;
    $robots['follow'] = true;
    unset($robots['max-image-preview']);
  } elseif (is_tag()) {
    $robots['noindex'] = true;
    $robots['follow'] = true;
  } else {
    $robots['index'] = true;
    $robots['follow'] = true;
    $robots['max-image-preview'] = 'large';
  }
  return $robots;
}

add_action('wp_head', 'dw_structured_data', 5);
function dw_structured_data() {
  if (is_single()) {
    $schema = [
      '@context' => 'https://schema.org',
      '@type' => 'Article',
      'headline' => get_the_title(),
      'author' => [
        '@type' => 'Person',
        '@id' => 'https://me.dwiyanti.com/#person',
        'name' => 'Dwi Yanti'
      ],
      'datePublished' => get_the_date('c'),
      'dateModified' => get_the_modified_date('c'),
      'mainEntityOfPage' => get_permalink()
    ];
    echo '<script type="application/ld+json">'
      . wp_json_encode($schema, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE)
      . '</script>';
  }
  // Additional conditions for other page types...
}

The Results: What Google Did

I monitored both sites — Dwi Yanti’s main site (my personal portfolio) and the Abdul Majid 25 Urban Residence site — for 3+ months after the plugin removal and custom code implementation. These were the measurable outcomes:

The most significant change was not ranking position — it was the Google AI Overview appearances. The Urban Residence site began surfacing in AI Overviews for queries like "kost eksklusif Jakarta Selatan fasilitas lengkap." The portfolio site appeared in AI Overviews for SEO specialist-related queries.

This is not coincidental. AI Overviews pull from pages with precise, well-structured schema, clear topical authority, and fast, technically clean pages. All three improved after removing the plugin overhead and replacing it with purpose-built structured data.

What This Experiment Taught Me About SEO Plugins

I am Dwi Yanti Technical SEO Specialist not saying SEO plugins are bad. For someone without development capability, they are better than nothing. But there is a fundamental misunderstanding in how most people use them: they treat plugin output as the goal, when it is only a shortcut to the goal.

The actual goal after SEO optimization expert is clean, accurate HTML signals in the page source. A plugin is one way to get there. Custom code is another. The difference is precision — and precision, at the level of individual page types, individual schema properties, individual canonical edge cases, is what separates a site that ranks from a site that dominates.

The Honest Caveat: This Requires Real Technical Skill

This approach requires real technical capability. As Dwi Yanti, I want to be direct about something: this approach requires you to actually understand WordPress PHP, its hooks system, its conditional functions, and how HTML head output works. If you remove an SEO plugin without replacing its output correctly, you will likely lose rankings — not because custom code is worse, but because incomplete custom code is worse than complete plugin code.

The prerequisite skill set:

• Comfort reading and writing PHP conditionals and WordPress functions
• Understanding of WordPress hook system (add_action, add_filter)
• Ability to validate output using browser DevTools (View Source)
• Access to Google Search Console for URL Inspection post-change
• Familiarity with schema.org vocabulary and Google's Rich Results Test

If you have these — or you work with someone who does — the plugin-free approach is technically superior. If you do not, a well-configured SEO plugin is still a valid path. The goal is not to avoid plugins out of principle. The goal is accurate, efficient SEO output.