Audit Kinerja Frontend: Mengukur dan Mengoptimalkan Total Blocking Time (TBT) dan Long Tasks

Membedah penyebab keterlambatan input respons: profiling Chrome Performance tab, pemecahan loop synchronous berat menggunakan scheduler.yield(), offloading Web Workers, dan optimasi hydration Next.js.

PuluhLabs Frontend Team, Lead Web Performance Specialist · 13 November 2026 · 6 min baca

Audit Kinerja Frontend: Mengukur dan Mengoptimalkan Total Blocking Time (TBT) dan Long Tasks
SEO & Performa
DECOUPLED

Isi artikel ini

  • Anatomi Long Task dan Dampaknya pada Main Thread
  • Menganalisis Titik Macet di Chrome DevTools Performance Tab
  • Strategi Remediasi: Pemecahan Task Menggunakan scheduler.yield()
  • Memindahkan Komputasi Berat ke Web Worker
  • Optimasi Hydration dan Dynamic Import pada Next.js
  • Pemantauan RUM (Real User Monitoring) dengan PerformanceObserver

Pada metrik performa web modern Google Core Web Vitals, metrik Interaction to Next Paint (INP) dan Total Blocking Time (TBT) berfokus langsung pada responsivitas antarmuka. Sebuah website dapat memuat konten visual dengan cepat (skor LCP baik), tetapi jika thread utama browser (main thread) dibebani oleh eksekusi skrip JavaScript yang berat, pengguna akan merasakan keterlambatan respons saat menekan tombol navigasi, membuka filter, atau mengetik di formulir.

Penyebab paling dominan dari tingginya skor TBT adalah keberadaan Long Tasks, yaitu eksekusi JavaScript yang memblokir main thread lebih dari 50 milidetik.

Anatomi Long Task dan Dampaknya pada Main Thread #

Browser menjalankan proses rendering tata letak (layout), penggambaran piksel (paint), dan komputasi JavaScript dalam satu antrean sekuensial pada main thread.

text
Antrean Main Thread Browser:
[Task Singkat: 20ms] [Task Singkat: 15ms] [========== Long Task: 180ms ==========] [Input User]
                                          ├──────── 50ms ────────┤◄─── TBT: 130ms ──►│ (Tertahan)

Ketika sebuah task memakan waktu 180 milidetik:

  • Ambang batas aman adalah 50 milidetik.
  • Selisih 130 milidetik dihitung sebagai waktu pemblokiran (blocking time).
  • Jika pengguna melakukan klik selama rentang 180 milidetik tersebut, browser tidak dapat memproses event input sampai task selesai dieksekusi. Akibatnya, input latency membengkak dan skor INP memburuk.

Total Blocking Time (TBT) adalah akumulasi seluruh blocking time dari task yang melebihi 50 ms antara First Contentful Paint (FCP) dan Time to Interactive (TTI).

Menganalisis Titik Macet di Chrome DevTools Performance Tab #

Untuk mengidentifikasi kode JavaScript yang memicu Long Tasks:

  1. Buka Chrome DevTools pada jendela penyamaran (Incognito Window).
  2. Pilih tab Performance, aktifkan CPU: 4x slowdown untuk mensimulasikan perangkat ponsel kelas menengah.
  3. Rekam interaksi saat memuat halaman atau menekan elemen interaktif.
  4. Perhatikan bagian antrean Main: cari blok berwarna abu-abu dengan sudut merah bergaris (red corner flag), yang menandakan deteksi Long Task.
  5. Klik tab Bottom-Up di panel bawah: urutkan berdasarkan Self Time untuk melihat fungsi kalkulasi spesifik mana yang menghabiskan waktu komputasi terbesar (misalnya serialisasi objek besar, manipulasi DOM berulang, atau parsing bundle third-party).

Strategi Remediasi: Pemecahan Task Menggunakan scheduler.yield() #

Pendekatan konvensional memecah loop besar adalah menggunakan setTimeout(fn, 0). Namun, setTimeout memiliki penalti latensi bawaan minimal 4 milidetik di browser dan menaruh callback di ujung akhir task queue, menunda proses rendering visual.

Standar web modern memperkenalkan API native scheduler.yield(). API ini mengembalikan kendali ke browser untuk menyelesaikan rendering dan memproses event input yang tertunda, lalu melanjutkan eksekusi JavaScript tepat setelahnya tanpa kehilangan prioritas task.

Berikut adalah implementasi helper TypeScript untuk mengeksekusi iterasi data besar secara non-blocking:

typescript
// Helper scheduler.yield() dengan fallback requestAnimationFrame / MessageChannel
export async function yieldToMainThread(): Promise<void> {
  if ('scheduler' in window && 'yield' in (window as any).scheduler) {
    return await (window as any).scheduler.yield();
  }

  // Fallback untuk browser lawas menggunakan MessageChannel (lebih cepat daripada setTimeout)
  return new Promise((resolve) => {
    const channel = new MessageChannel();
    channel.port1.onmessage = () => resolve();
    channel.port2.postMessage(null);
  });
}

// Fungsi pemrosesan array besar tanpa memicu Long Task
export async function processLargeDatasetChunked<T, R>(
  items: T[],
  processItem: (item: T) => R,
  maxExecutionTimeMs = 15
): Promise<R[]> {
  const results: R[] = [];
  let lastYieldTime = performance.now();

  for (let i = 0; i < items.length; i++) {
    results.push(processItem(items[i]));

    // Cek apakah waktu eksekusi saat ini sudah mendekati batas aman
    if (performance.now() - lastYieldTime > maxExecutionTimeMs) {
      await yieldToMainThread();
      lastYieldTime = performance.now();
    }
  }

  return results;
}

Dengan membatasi siklus eksekusi maksimal 15 milidetik per batch, main thread tidak pernah terblokir melebihi 50 milidetik, sehingga TBT terpangkas menjadi 0 milidetik.

Memindahkan Komputasi Berat ke Web Worker #

Jika pemrosesan data membutuhkan perhitungan matematika kompleks, parsing file CSV besar, atau manipulasi gambar kanvas, pekerjaan tersebut harus dipindahkan keluar dari main thread menggunakan Web Worker independen.

typescript
// worker.ts: Berjalan di thread background terpisah tanpa akses DOM
self.onmessage = (event: MessageEvent<{ data: number[] }>) => {
  const sorted = event.data.data.sort((a, b) => a - b);
  self.postMessage({ result: sorted });
};

// main.ts: Main thread tetap responsif untuk interaksi pengguna
const worker = new Worker(new URL('./worker.ts', import.meta.url));

export function sortDataInWorker(numbers: number[]): Promise<number[]> {
  return new Promise((resolve) => {
    worker.onmessage = (e) => resolve(e.data.result);
    worker.postMessage({ data: numbers });
  });
}

Optimasi Hydration dan Dynamic Import pada Next.js #

Pada aplikasi berbasis React dan Next.js App Router, Long Tasks sering terjadi saat fase Hydration, yaitu ketika React mengikat event listener ke seluruh markup HTML yang dirender dari server.

Langkah-langkah eliminasi TBT hydration:

  1. Dynamic Import Komponen Berat:
    Gunakan next/dynamic untuk komponen yang berada di bawah layar (below-the-fold) atau hanya muncul setelah interaksi pengguna (seperti modal, kalkulator kompleks, atau grafik analitik).
tsx
import dynamic from 'next/dynamic';

const InteractiveArchitectureDiagram = dynamic(
  () => import('@/components/InteractiveArchitectureDiagram'),
  {
    ssr: false,
    loading: () => <div className="h-96 animate-pulse bg-surface-subtle rounded-xl" />,
  }
);
  1. Isolasi Third-Party Scripts:
    Skrip pelacakan analitik dan tag marketing adalah sumber utama Long Tasks pihak ketiga. Gunakan strategi pemuatan strategy="lazyOnload" atau pindahkan eksekusi pelacakan pihak ketiga menggunakan Partytown ke background worker.

Pemantauan RUM (Real User Monitoring) dengan PerformanceObserver #

Untuk memantau durasi Long Tasks yang dialami pengguna secara real-time di lingkungan produksi, manfaatkan API PerformanceObserver:

typescript
if (typeof window !== 'undefined' && 'PerformanceObserver' in window) {
  try {
    const observer = new PerformanceObserver((entryList) => {
      for (const entry of entryList.getEntries()) {
        if (entry.duration > 50) {
          console.warn(`[Long Task Detected] Durasi: ${entry.duration.toFixed(1)} ms`, entry);
          // Kirim metrik ke endpoint telemetri internal
        }
      }
    });

    observer.observe({ entryTypes: ['longtask'] });
  } catch (e) {
    // Abaikan jika browser tidak mendukung entryType longtask
  }
}

Disiplin memecah eksekusi synchronous, menunda komponen berat, dan memindahkan komputasi intensif ke worker menjamin skor TBT tetap hijau dan antarmuka web selalu responsif terhadap setiap sentuhan pengguna.

Bagikan Artikel Ini:
Topik Terkait:Semua artikel: Performa web dan Core Web VitalsCore Web VitalsTotal Blocking TimeJavaScript PerformanceWeb WorkerNext.js
Istilah Teknis Terkait (Knowledge Graph Glossary)
Jejaring Entitas & Solusi Teknis Terkait
3 Solusi Terintegrasi
Diagnostic Tool

Estimator Skor Core Web Vitals

Uji latensi LCP, stabilitas CLS, dan responsivitas INP pada arsitektur web modern.

Buka Solusi
Performance Lab

Simulator Off-Main-Thread & INP

Analisis beban eksekusi JavaScript dan hilangkan thread blocking pada peramban mobile.

Buka Solusi
ROI Calculator

Kalkulator ROI & Pertumbuhan Konversi

Hitung potensi kenaikan omset bisnis dari penurunan bounce rate website.

Buka Solusi

PuluhLabs Frontend Team

Lead Web Performance Specialist

Terakhir diperbarui: 13 November 2026

Ingin Menerapkan Standar Performa Ini pada Proyek Agensi Anda?

Tim PuluhLabs siap menjadi mitra rekayasa digital rahasia (white-label) untuk agensi Anda. Garansi performa skor Lighthouse 90+, Core Web Vitals hijau, dan 100% hak milik kode.

Konsultasi Proyek Bersama Tim PuluhLabs

Artikel Rekomendasi Selanjutnya

Lihat Semua
  1. Performa Web

    Optimasi Core Web Vitals: Membedah dan Memperbaiki Cumulative Layout Shift (CLS) hingga Skor Nol

  2. Optimasi SEO

    Audit dan Remidiasi Metrik INP (Interaction to Next Paint) pada Aplikasi React Berbasis Data Berat

  3. Pengembangan Web

    Strategi Migrasi Next.js Pages Router ke App Router Tanpa Downtime