সরাসরি পর্বে যান
পর্ব ৫১ · ৮২-এর মধ্যে · মডিউল ৮

Frontend performance — Lighthouse আর Core Web Vitals

Frontend Performance Testing: Lighthouse and Core Web Vitals

Taught in Bangla, this lesson explains LCP, INP and CLS and lab versus field data judged at the 75th percentile. A real Lighthouse 13.6.0 run in Edge gives the Bazarghar product page a mobile LCP of 0.8 s; a seeded 4.7 MB banner and a head script push it to 25.1 s. Lighthouse CI takes the median of three runs and fails the budget with exit code 1. Playwright measures navigation timing and marks, showing how the measuring tool skews timings, and Bangla fonts, cache headers and JS size are checked.

এই পর্বে যা শিখবেন

  • LCP, INP আর CLS কী মাপে, তাদের সীমা কত, আর একটি পাতার performance requirement কীভাবে test-যোগ্য করে লিখবেন
  • Lab data আর field data-র পার্থক্য, আর কোনটি কোন সিদ্ধান্তে লাগে
  • Lighthouse CLI চালিয়ে মোবাইল আর desktop মাপা, report পড়া, আর একটি বসানো regression ধরা
  • Lighthouse CI-র assertion বা budget দিয়ে CI-তে performance gate বসানো
  • Playwright দিয়ে navigation timing, LCP আর performance mark মাপা, আর বাংলা font, ছবি, cache header ও JavaScript-এর আকার যাচাই করা

১ · ক্রেতা কী অনুভব করেন — server-এর বাইরের সময়

মোড়ের মুদি দোকানে ঢুকলেন। দোকানি সাথে সাথে বললেন “কী লাগবে?”, অর্থাৎ server দ্রুত সাড়া দিল। কিন্তু চালের বস্তা পেছনের গুদামে, আনতে দশ মিনিট। মাঝখানে কেউ তাক সরাতে গিয়ে আপনার হাতের ব্যাগ ফেলে দিলেন। আর দাম জিজ্ঞেস করলে দোকানি অন্য ক্রেতার হিসাব শেষ না করে উত্তর দেন না। দোকানির প্রথম সাড়া দ্রুত ছিল, তবু আপনার অভিজ্ঞতা খারাপ।

ওয়েবেও তাই। পর্ব ৪৬ থেকে ৫০ পর্যন্ত আমরা server-এর দিক মেপেছি: পর্ব ৪৬-এ percentile আর NFR-2, পর্ব ৪৭ আর ৪৮-এ Locust আর k6, পর্ব ৪৯-এ bottleneck, পর্ব ৫০-এ SLO আর capacity. বাজারঘরের পণ্যের পাতার HTML server থেকে আসে কয়েক মিলিসেকেন্ডে। কিন্তু ক্রেতা ফোনে যা দেখেন, তা নির্ভর করে আরও অনেক কিছুর ওপর: কতগুলো ফাইল নামাতে হলো, ছবি কত বড়, কোন script পাতা আঁকা আটকে রাখল, font কখন এল, আর ফোনের CPU কত ধীর। এই অংশের performance-কে বলে frontend performance, আর এর test হয় browser-এর ভেতর থেকে।

মূল ধারণা

Backend load test প্রশ্ন করে “অনেকে একসাথে এলে server কত দ্রুত উত্তর দেয়?” Frontend performance test প্রশ্ন করে “একজন ক্রেতা, তাঁর ফোন আর নেটওয়ার্কে, পাতাটি কত দ্রুত দেখেন, ব্যবহার করতে পারেন আর পাতাটি কতটা স্থির থাকে?” প্রথমটির জন্য অনেক virtual user, দ্বিতীয়টির জন্য একটি সত্যিকারের browser.

Tester হিসেবে এখানে আপনার কাজ তিনটি। এক, “পাতা দ্রুত হবে” কথাটিকে মাপা যায় এমন requirement-এ বদলানো। দুই, এমন test বানানো, যা প্রতিটি পরিবর্তনের পরে চলে আর ধীর হলে লাল হয়। তিন, ফল পড়তে জানা: কোন সংখ্যা বিশ্বাস করা যায়, কোনটি মাপার পদ্ধতির ভুল। কীভাবে পাতা দ্রুত বানাতে হয়, তা developer-এর বিষয়; সেটি HTML ও CSS কোর্সের পর্ব ৪৯ আর ফুল-স্ট্যাক কোর্সের পর্ব ৮৪-এ বিস্তারিত আছে। এখানে আমরা মাপা, ধরা আর আটকানোর দিকে থাকব।

২ · Core Web Vitals — তিনটি সংখ্যা, তিনটি প্রশ্ন

Google-এর Chrome দল ব্যবহারকারীর অভিজ্ঞতাকে তিনটি মাপে বেঁধেছে, নাম Core Web Vitals. প্রতিটির সাথে একটি প্রশ্ন আর একটি সীমা আছে। সীমাগুলো web.dev-এর বর্তমান লেখা অনুযায়ী (এই পর্ব লেখার সময়, নভেম্বর ২০২৬); নিয়ম বদলাতে পারে, তাই নিজের gate বসানোর আগে একবার মিলিয়ে নেবেন।

LCP · দেখা গেল কখন

Largest Contentful Paint: পর্দায় সবচেয়ে বড় ছবি বা লেখার খণ্ড কখন আঁকা হলো। ভালো ≤ ২.৫ s, ৪ s-এর বেশি খারাপ।

লোড

INP · সাড়া এল কখন

Interaction to Next Paint: ক্লিক, ট্যাপ বা কী চাপার পর পরের ছবি আঁকা পর্যন্ত সময়, পুরো ভিজিটের প্রায় সবচেয়ে খারাপটি। ভালো ≤ ২০০ ms, ৫০০ ms-এর বেশি খারাপ।

সাড়া

CLS · পাতা লাফাল কি

Cumulative Layout Shift: হঠাৎ সরে যাওয়া জিনিসের score, সবচেয়ে খারাপ “দল” ধরে। ভালো ≤ ০.১, ০.২৫-এর বেশি খারাপ। কোনো একক নেই।

স্থিরতা

দুটি নিয়ম test লেখার সময় খুব জরুরি। প্রথমত, রায় হয় আসল page view-গুলোর 75th percentile ধরে, মোবাইল আর desktop আলাদা করে: চারজনের অন্তত তিনজনের অভিজ্ঞতা সীমার ভেতরে থাকতে হবে। গড় নয়, কারণ পর্ব ৪৬-এ দেখেছেন গড় ধীর লেজ লুকিয়ে ফেলে। দ্বিতীয়ত, তিনটির পাশে কয়েকটি সহায়ক মাপ আছে, যেগুলো রায়ের অংশ নয় কিন্তু কারণ খুঁজতে কাজে লাগে: TTFB (server থেকে প্রথম byte), FCP (প্রথম কিছু আঁকা) আর TBT (লোডের সময় main thread কতক্ষণ আটকে ছিল)।

Google ২০২০ সালে Core Web Vitals নামটি আনে; তখন তিনটি ছিল LCP, FID (First Input Delay) আর CLS. FID শুধু প্রথম ক্লিকের অপেক্ষা মাপত, ক্লিকের কাজ আর পরের আঁকা নয়। তাই ২০২৪ সালের মার্চে INP স্থায়ীভাবে FID-এর জায়গা নেয় বলে Chrome দল ঘোষণা করে। CLS-এর হিসাবও ২০২১ সালের দিকে “session window” ভিত্তিক হয় (§৮)। Tester-এর শিক্ষা: মাপের সংজ্ঞা বদলায়, তাই test-এ লিখে রাখুন কোন সংজ্ঞা আর কোন tool-এর কোন version দিয়ে মাপছেন।

“পাতা দ্রুত হবে” থেকে test-যোগ্য requirement

পর্ব ১৫-এ (Requirement থেকে test) server-এর জন্য NFR-2 লিখেছিলেন। পণ্যের পাতার জন্য একই কাজ। Product owner বললেন, “পণ্যের পাতা ফোনে চটপট খুলবে, আর লাফাবে না।” Tester-এর প্রশ্নের পর দাঁড়াল, ধরুন NFR-5: “মোবাইলে পণ্যের পাতার field data-য় p75 LCP ≤ ২.৫ s, p75 INP ≤ ২০০ ms, p75 CLS ≤ ০.১. প্রতিটি release-এর আগে lab-এ (Lighthouse মোবাইল, ৩টি run-এর median) LCP ≤ ২.৫ s, TBT ≤ ২০০ ms, CLS ≤ ০.১ আর পাতার মোট ওজন ≤ ৩০০ KB.” লক্ষ করুন, একটি বাক্যে দুটি স্তর: রায়ের জন্য field, আর release আটকানোর জন্য lab. Lab-এ INP মাপা যায় না, কারণ কেউ ক্লিক করেন না; তার জায়গায় TBT.

LCP ঠিক কী মাপে, সেটি একটি পাতা ধরে দেখা দরকার, কারণ “সবচেয়ে বড় জিনিস” লোডের সাথে বদলায়। নিচের stepper-এ বাজারঘরের পণ্যের পাতা (/products/1, মিনিকেট চাল) দুইবার খোলা হয়েছে, Playwright আর Edge দিয়ে, নেটওয়ার্ক ধীর করে (১৫০ ms দেরি, ১.৬ Mbps; §৭)। একবার ঠিক build, একবার §৫-এর ব্যানার-ওয়ালা build. সংখ্যাগুলো সেই সত্যিকারের run-এর।

1GET /products/12HTML-এর প্রথম byte3HTML পড়া শেষ4প্রথম আঁকা: h15বড় ছবি এল6ক্রেতা স্ক্রল করলেন
সময় (ms) আর LCP candidate
ঠিক build
ব্যানার build
  1. শুরু। ঘড়ি শুরু হয় navigation-এর মুহূর্তে, অর্থাৎ ক্রেতা লিংকে চাপ দেওয়ার সময় থেকে। LCP তাই server-এর সময়, নেটওয়ার্ক আর browser-এর কাজ, সব একসাথে ধরে।
  2. প্রথম byte. দুই build-এই TTFB ১৫২ ms: নেটওয়ার্কের নকল দেরি ১৫০ ms আর server-এর মাত্র কয়েক ms. Server-এর দিক থেকে দুই build একই রকম দ্রুত।
  3. HTML পড়া শেষ। ঠিক build-এ DOMContentLoaded ৩৯৮ ms-এ, ব্যানার build-এ ৭৯৫ ms-এ. পার্থক্যের কারণ head-এর একটি সাধারণ <script>: সেটি নামা আর চলা শেষ না হলে browser HTML পড়া আর আঁকা থামিয়ে রাখে।
  4. প্রথম candidate. ঠিক build-এ পর্দার সবচেয়ে বড় জিনিস পণ্যের নাম, h1; সেটি আঁকা হলো ৪৫২ ms-এ, তাই LCP ৪৫২ ms. ব্যানার build-এও প্রথমে h1 আঁকা হয়, কিন্তু তখনো ব্যানারের ছবি নামছে।
  5. বড় ছবি। ঠিক build-এ ছবি নেই, LCP ৪৫২-তেই থাকে। ব্যানার build-এ ২৪০০×১২০০ ছবিটি পুরো নামার পর আঁকা হলো ২৪৯৪৮ ms-এ; এটি h1-এর চেয়ে বড়, তাই browser নতুন LCP entry লিখল। LCP = ২৪.৯ সেকেন্ড, সীমার প্রায় দশ গুণ।
  6. থামা। ক্রেতা ক্লিক বা স্ক্রল করলে browser LCP খোঁজা থামায়। তাই একটি automated test-এ মাপার আগে কিছু চাপবেন না, আর মান পড়বেন লোড শেষে। LCP-র নিয়মের খুঁটিনাটি (কোন element গোনা হয়, কোনটি নয়) web.dev-এ আছে।

৩ · Lab data বনাম field data

Performance-এর মাপ দুই জায়গা থেকে আসে। Lab data: আপনি একটি নির্দিষ্ট যন্ত্রে, নির্দিষ্ট নকল নেটওয়ার্ক আর CPU ধরে মাপেন, যেমন Lighthouse বা Playwright দিয়ে। বারবার একই অবস্থা পাওয়া যায়, তাই দুই build-এর তুলনা আর ভুল খোঁজা সহজ। Field data: আসল ক্রেতার browser থেকে আসা মাপ, রাজশাহীর পুরোনো Android থেকে ঢাকার নতুন ল্যাপটপ পর্যন্ত। এটি সংগ্রহের পদ্ধতিকে বলে RUM (Real User Monitoring). বড় সাইটের জন্য Google-এর CrUX (Chrome User Experience Report) নামে একটি সমষ্টিগত field dataset-ও আছে, যা যথেষ্ট ভিজিট থাকলে পাওয়া যায়; বাজারঘরের মতো ছোট বা নতুন সাইটের জন্য প্রায়ই সেখানে ডেটা থাকে না।

একটি page view-এর মাপ, আর কোথা থেকে তা আসে

One page view on a timeline; lab tools and field monitoring measure it differently

Page view-এর সময়রেখা, lab আর field-এর মাপ শুরু: লিংকে চাপ TTFB: HTML-এর প্রথম byte FCP: প্রথম কিছু আঁকা LCP: সবচেয়ে বড় জিনিস আঁকা CLS: কিছু হঠাৎ সরে গেল INP: ক্লিক → পরের আঁকা Lab Lighthouse, Playwright এক যন্ত্র, নকল নেটওয়ার্ক ক্লিক নেই: INP-এর বদলে TBT কাজ: তুলনা, CI gate Field RUM, CrUX নানা ফোন, নেটওয়ার্ক তিনটি মাপই, 75th percentile কাজ: রায় সিদ্ধান্ত
ছবি ৫১.১ — ওপরে একটি page view-এর সময়রেখা। Lab একই page view বারবার নিয়ন্ত্রিত অবস্থায় মাপে; field হাজারো আসল page view থেকে percentile বের করে। দুটোই লাগে, কাজ আলাদা।

একই পাতার জন্য তিন রকম মাপ পাশাপাশি রাখলে পার্থক্য স্পষ্ট হয়। নিচের stepper-এ ব্যানার build-এর পণ্যের পাতা: Lighthouse-এর দুই মোড, Playwright-এর মাপ, আর একটি field-এর নমুনা (৮টি কাল্পনিক page view, ঠিক build-এর; বাজারঘরের কোনো আসল ক্রেতা নেই)।

  1. Lighthouse মোবাইলsimulateনকল ফোন
  2. Lighthouse desktoppresetদ্রুত যন্ত্র
  3. PlaywrightCDPসত্যিই ধীর নেটওয়ার্ক
  4. Field (নমুনা)p75আসল ক্রেতা
Lighthouse 13.6.0মোবাইল, ৩টি run
RTT 150 ms · 1.6 Mbps · CPU ÷4
LCP  25.1 s   (৩ run-এ একই)
TBT  0 ms     CLS 0
হিসাব করা সময়, মডেল দিয়ে
Lighthouse 13.6.0desktop preset
RTT 40 ms · 10 Mbps · CPU ÷1
LCP  4.1 s    score 79
একই পাতা, ছয় গুণ কম LCP
Playwright + Edge১৫০ ms, ১.৬ Mbps
ttfb 152 · dcl 795 · load 24925
LCP  24948 ms   CLS 0
সত্যিই নামানো, ঘড়ি দিয়ে মাপা
Field, নমুনা৮টি page view, ঠিক build
LCP (s): 1.1 1.4 1.6 1.9
         2.2 2.7 3.8 6.0
p75 = ৬ নম্বর = 2.7 s  → উন্নতি দরকার
lab-এ 0.8 s, field-এ 2.7 s
  1. Lighthouse মোবাইল। Lighthouse পাতাটি দ্রুত নামিয়ে একটি মডেল দিয়ে হিসাব করে ধীর ফোনে কত লাগত: প্রতি round trip ১৫০ ms, প্রায় ১.৬ Mbps, CPU চার গুণ ধীর। একে বলে simulated throttling. তিনটি run-এ হুবহু একই ২৫.১ s, কারণ হিসাবটি মডেলের।
  2. Lighthouse desktop. --preset=desktop-এ RTT ৪০ ms, ১০ Mbps, CPU-তে কোনো ধীরতা নেই। একই পাতায় LCP ৪.১ s. “পাতা কত দ্রুত” প্রশ্নের উত্তর কোন যন্ত্র ধরে মাপছেন তার ওপর নির্ভর করে; তাই requirement-এ যন্ত্র লিখতে হয়।
  3. Playwright. এখানে নেটওয়ার্ক সত্যিই ধীর করা হয়েছে (CDP দিয়ে, §৭), আর browser নিজের ঘড়িতে মেপেছে: LCP ২৪৯৪৮ ms. Lighthouse-এর হিসাবের সাথে প্রায় মিলে গেল, কারণ সময়ের প্রায় সবটাই ৪.৭ MB ছবি নামাতে।
  4. Field. নমুনার আটটি LCP সাজালে ⌈০.৭৫ × ৮⌉ = ৬ নম্বর মান ২.৭ s, সীমার ওপরে। Lab-এ ঠিক build-এর LCP মাত্র ০.৮ s ছিল; আসল ক্রেতাদের মধ্যে কারও ফোন পুরোনো, কারও নেটওয়ার্ক দুর্বল। Lab সবুজ মানে field সবুজ নয়; উল্টোটাও সব সময় সত্য নয়।

৪ · সত্যিকারের run — Edge-এ Lighthouse CLI

Lighthouse হলো Google-এর খোলা উৎসের tool (Apache-2.0), যা একটি পাতা browser-এ খুলে মাপে আর কোথায় সমস্যা তার তালিকা দেয়। Command line থেকে চালানো যায়, তাই test-এর মতো স্বয়ংক্রিয় করা যায়।

Lab-এর পরিবেশ: একটি Windows ডেস্কটপে, আলাদা scratch ফোল্ডারে। Node 24.15.0; সেই ফোল্ডারে local npm install: lighthouse 13.6.0 আর @lhci/cli 0.16.1 (দুটোই Apache-2.0). Browser হলো কম্পিউটারে আগে থেকে থাকা Microsoft Edge 157, headless, CHROME_PATH দিয়ে দেখানো। বাজারঘরের app (MIT) নিজের কপি থেকে চলেছে 127.0.0.1:8826-এ, একটি worker-এ. Lighthouse প্রথম run-এ error report পাঠানোর অনুমতি চাইতে পারে; --no-enable-error-reporting দিয়ে সেটি বন্ধ রাখা হয়েছে, আর কোনো report কোথাও upload হয়নি। Path নিরপেক্ষ করা।

cd ~/bazarghar-qa/lh
npm init -y
npm install --save-exact lighthouse@13.6.0 @lhci/cli@0.16.1 --no-audit --no-fund
export CHROME_PATH="C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
npx lighthouse http://127.0.0.1:8826/products/1 \
    --only-categories=performance --no-enable-error-reporting \
    --output=json --output-path=./reports/clean-prod-mobile-1.json \
    --chrome-flags="--headless=new"
# desktop: add --preset=desktop

JSON report-এ মাপের পাশাপাশি যন্ত্রের নানা তথ্যও থাকে (browser-এর user agent, CPU-র একটি benchmark সংখ্যা ইত্যাদি)। রিপোর্ট কাউকে পাঠানোর আগে সেগুলো বাদ দিন। একটি ছোট Python script শুধু দরকারি অংশ বের করেছে। মোবাইল মোডে Lighthouse কী নকল করেছে (সত্যিকারের run):

lighthouse 13.6.0  formFactor: mobile  screen: 412 x 823, DPR 1.75
throttlingMethod: simulate  rttMs 150  throughputKbps 1638.4  cpuSlowdownMultiplier 4
LCP element: <h1 data-testid="product-title"> | মিনিকেট চাল ৫ কেজি

হোম আর পণ্যের পাতা, মোবাইল আর desktop, প্রতিটি তিনবার (সত্যিকারের run, প্রতিটির ৩টি run-এ মান হুবহু এক ছিল, তাই একটি করে লাইন):

clean-home-mobile    score 100  FCP 0.8 s  LCP 0.8 s  TBT 0 ms  CLS 0.000  bytes 19 KiB
clean-home-desktop   score 100  FCP 0.3 s  LCP 0.3 s  TBT 0 ms  CLS 0.000  bytes 19 KiB
clean-prod-mobile    score 100  FCP 0.8 s  LCP 0.8 s  TBT 0 ms  CLS 0.000  bytes 15 KiB
clean-prod-desktop   score 100  FCP 0.3 s  LCP 0.3 s  TBT 0 ms  CLS 0.000  bytes 15 KiB

বাজারঘরের পাতা ছোট: কোনো ছবি নেই, CSS ৪ KB, JavaScript ৩ KB, আর font আসে ফোনের নিজের থেকে। তাই score ১০০. তবু score ১০০ মানে “কিছু খোঁজার নেই” নয়। Score-এর নিচে Lighthouse-এর insight-এর তালিকায় পণ্যের পাতার মোবাইল run তিনটি জিনিস দেখাল (সত্যিকারের run):

0.5   cache-insight             Use efficient cache lifetimes  Est savings of 8 KiB
0.5   document-latency-insight  Document request latency       Est savings of 4 KiB
0     render-blocking-insight   Render-blocking requests       Est savings of 110 ms

তিনটিই tester-এর কাজের তথ্য। প্রথমটি বলছে CSS আর JS ফাইলে cache কতক্ষণ রাখা যাবে তা বলা নেই, অর্থাৎ Cache-Control header নেই (§৮-এ নিজে যাচাই করব)। দ্বিতীয়টির ভেতরে Lighthouse লিখেছে “No compression applied”: HTML gzip বা Brotli ছাড়া আসছে। তৃতীয়টি বলছে head-এর stylesheet আঁকা আটকায়, যা প্রায় সব পাতাতেই একটু থাকে; ১১০ ms সঞ্চয়ের অনুমান ছোট। এগুলো bug report না-ও হতে পারে, কিন্তু release-এর আগে দলকে জানানো উচিত, বিশেষ করে cache আর compression, কারণ ছবি আর বড় JS যোগ হলে এগুলোর খরচ বহুগুণ বাড়বে।

Score-কে লক্ষ্য বানাবেন না। Lighthouse 13.6.0-এর performance score পাঁচটি lab মাপের ওজন দেওয়া মিশ্রণ: TBT ৩০, LCP ২৫, CLS ২৫, FCP ১০, Speed Index ১০ (এই version-এর default config থেকে মেলানো)। ওজন version-ভেদে বদলেছে। Gate বসান আলাদা আলাদা মাপের ওপর, যার অর্থ পরিষ্কার; score শুধু সতর্কবার্তা হিসেবে রাখুন।

৫ · একটি বসানো regression — ঈদের ব্যানার

এবার নিজের app-কপিতে একটি পরিচিত ধরনের ভুল বসানো হলো, একটি environment variable দিয়ে চালু করা যায় এমনভাবে (BAZARGHAR_PERF_BUG=1; এটি শুধু এই lab-এর কপিতে, কোর্সের মূল app-এ নেই)। মার্কেটিং দল ঈদের অফারের জন্য দুটি জিনিস চেয়েছে, আর তাড়াহুড়োয় দুটোই সবচেয়ে খারাপভাবে বসেছে:

  • প্রতিটি পাতার ওপরে একটি ব্যানার ছবি: ২৪০০×১২০০ PNG, প্রায় ৪.৭ MB, width আর height ছাড়া। (ছবিটি একটি script-এ বানানো gradient আর noise; আসল ছবির মতোই এটি ভালোভাবে সংকুচিত হয় না।)
  • head-এ একটি সাধারণ <script src="/static/promo.js">, defer বা async ছাড়া, যা ৩৫০ ms ধরে main thread ব্যস্ত রাখে, যেন অফারের হিসাব করছে।

একই command, একই তিনবার করে (সত্যিকারের run):

bug-home-mobile      score  72  FCP 2.3 s  LCP 25.1 s  TBT 0 ms  CLS 0.000  bytes 4,784 KiB
bug-home-desktop     score  79  FCP 0.6 s  LCP 4.1 s   TBT 0 ms  CLS 0.000  bytes 4,784 KiB
bug-prod-mobile      score  72  FCP 2.3 s  LCP 25.1 s  TBT 0 ms  CLS 0.000  bytes 4,780 KiB
bug-prod-desktop     score  79  FCP 0.6 s  LCP 4.1 s   TBT 0 ms  CLS 0.000  bytes 4,780 KiB

পণ্যের পাতার মোবাইল run-এ LCP element এখন ব্যানার, আর ব্যর্থ audit-গুলোর মূলগুলো (সত্যিকারের run, Lighthouse-এর নিজের ভাষায়):

LCP element: <img class="promo" src="/static/eid-banner.png" alt="ঈদের অফার: সব তেলে ছাড়">
0     largest-contentful-paint  Largest Contentful Paint            25.1 s
0.5   bootup-time               Reduce JavaScript execution time    1.4 s
0.5   unsized-images            Image elements do not have explicit `width` and `height`
0.5   total-byte-weight         Avoid enormous network payloads     Total size was 4,780 KiB
0     image-delivery-insight    Improve image delivery              Est savings of 4,727 KiB
0     render-blocking-insight   Render-blocking requests            Est savings of 1,660 ms

সংখ্যাগুলো হিসাব করে মিলিয়ে দেখুন, এটিই tester-এর অভ্যাস। ৪৭৮০ KiB মানে প্রায় ৩.৯২ কোটি bit; ১৬৩৮.৪ Kbps গতিতে নামাতে ৪৭৮০ × ১০২৪ × ৮ ÷ ১৬৩৮৪০০ ≈ ২৩.৯ সেকেন্ড। বাকি এক সেকেন্ডের মতো যায় round trip আর আঁকায়। অর্থাৎ ২৫.১ s-এর প্রায় সবটাই একটি ছবির ওজন। “Improve image delivery” বলছে ৪৭২৭ KiB বাঁচানো সম্ভব: পর্দায় ছবিটি অনেক ছোট দেখায়, আর আধুনিক format-এ ফাইল অনেক ছোট হতো। কীভাবে, তা HTML ও CSS কোর্সের পর্ব ৩২-এর বিষয়।

দুটি অবাক করা শূন্য

TBT ০ ms, অথচ script ৩৫০ ms main thread আটকে রেখেছে, আর Lighthouse নিজেই “JavaScript execution time 1.4 s” বলছে (৪ গুণ ধীর CPU-তে)। কারণ TBT গোনে শুধু FCP-র পরের আটকানো সময়। Head-এর script চলে প্রথম আঁকার আগে, তাই তার খরচ TBT-তে নয়, FCP-তে পড়ে: FCP ০.৮ থেকে ২.৩ s. একটি মাপ শূন্য দেখালে “সব ঠিক” ধরে নেবেন না; জিজ্ঞেস করুন মাপটি কোন সময়ের জানালা দেখে।

CLS ০, অথচ ছবিতে width-height নেই। এই lab-এ ব্যানারের মাপ (PNG ফাইলের শুরুতেই লেখা থাকে) প্রথম আঁকার আগেই browser জেনে গিয়েছিল, কারণ head-এর script নিজেই আঁকা দেরি করিয়েছে। তাই কিছু সরেনি। আসল ফোনে, ভিন্ন ক্রমে ফাইল এলে, ছবি আসার মুহূর্তে নিচের লেখা লাফাতে পারে। Lighthouse তাই আলাদা audit-এ (unsized-images) ঝুঁকিটি জানিয়েছে। Lab-এর CLS শূন্য মানে “এই একটি load-এ সরেনি”, “কখনো সরবে না” নয়।

৬ · Performance budget আর CI gate — Lighthouse CI

একবার মাপা যথেষ্ট নয়; প্রতিটি পরিবর্তনে মাপতে হবে, আর সীমা ছাড়ালে build আটকাতে হবে। আগে থেকে সংখ্যায় লেখা এই সীমাকে বলে performance budget: যেমন “পাতার মোট ওজন ≤ ৩০০ KB, LCP ≤ ২.৫ s”. পরিবারের মাসের বাজারের বাজেটের মতো: বাজেট না থাকলে প্রতিটি “ছোট্ট” কেনা আলাদাভাবে যুক্তিসংগত মনে হয়, মাস শেষে হিসাব মেলে না।

Lighthouse 13.6.0-এর CLI-তে budget-এর কোনো option নেই (installed প্যাকেজের option-এর তালিকায় মিলিয়ে দেখা); পুরোনো version-এর budget ব্যবস্থা নতুনগুলোতে সরানো হয়েছে। এখন এই কাজের tool Lighthouse CI (@lhci/cli): একই URL কয়েকবার মাপে (collect), তারপর আপনার লেখা assertion মেলায় (assert) আর না মিললে non-zero exit code দেয়। পুরোনো ধাঁচের budgets.json ফাইলও assert নিতে পারে (--budgetsFile), নিজে assertion-এ বদলে। ফল কোথাও upload করার একটি আলাদা upload ধাপ আছে; এই lab-এ সেটি একবারও চালানো হয়নি, সব ফল নিজের ফোল্ডারে থেকেছে।

{
  "ci": {
    "collect": {
      "url": ["http://127.0.0.1:8826/products/1"],
      "numberOfRuns": 3,
      "settings": {"onlyCategories": ["performance"],
                   "chromeFlags": "--headless=new --no-first-run"}
    },
    "assert": {
      "assertions": {
        "largest-contentful-paint": ["error", {"maxNumericValue": 2500, "aggregationMethod": "median"}],
        "cumulative-layout-shift": ["error", {"maxNumericValue": 0.1, "aggregationMethod": "median"}],
        "total-blocking-time": ["error", {"maxNumericValue": 200, "aggregationMethod": "median"}],
        "total-byte-weight": ["error", {"maxNumericValue": 300000}],
        "unsized-images": "error",
        "categories:performance": ["warn", {"minScore": 0.9}]
      }
    }
  }
}

লক্ষ করুন, NFR-5-এর lab অংশটি প্রায় হুবহু config হয়ে গেল। aggregationMethod: "median" মানে তিনটি run-এর মাঝের মান দিয়ে বিচার; একটি অস্বাভাবিক run একা gate উল্টাতে পারবে না। Score শুধু warn. ব্যানার build-এ (সত্যিকারের run, রং বাদ দেওয়া, কিছু লাইন ছাঁটা):

$ npx lhci collect && npx lhci assert
Running Lighthouse 3 time(s) on http://127.0.0.1:8826/products/1
Run #1...done.
Run #2...done.
Run #3...done.
Checking assertions against 1 URL(s), 3 total run(s)

4 result(s) for http://127.0.0.1:8826/products/1 :
  ×  largest-contentful-paint failure for maxNumericValue assertion
        expected: <=2500
           found: 25057.9871
      all values: 25058.8796, 25057.6484, 25057.9871
  ×  total-byte-weight failure for maxNumericValue assertion
        expected: <=300000
           found: 4894340
  ×  unsized-images failure for minScore assertion
        expected: >=0.9
           found: 0.5
  ⚠️  categories.performance warning for minScore assertion
        expected: >=0.9
           found: 0.72
Assertion failed. Exiting with status code 1.

ঠিক build-এ একই command-এর শেষ লাইনগুলো ছিল Checking assertions against 1 URL(s), 3 total run(s) আর All results processed!, exit code 0; তিন run-এ LCP ৭৫৪.৪, ৭৫৪.৬ আর ৭৫৫.২ ms, ওজন ১৫২০১ byte. CI-তে exit code 0 মানে পরের ধাপে যাওয়া, 1 মানে থামা: একটি quality gate. CI pipeline-এ gate কোথায় বসে, তা পর্ব ৬৪-এ (CI-তে test pipeline) আসবে।

পণ্যের পাতা, মোবাইল lab
ধাপ
LCP
ওজন
বাকি
  1. Baseline. শেষ ভালো build-এর মাপ: LCP-র median ৭৫৪.৬ ms, ওজন ১৫২০১ byte, TBT আর CLS শূন্য, score ১. এর সাথেই নতুন build তুলনা হবে।
  2. পরিবর্তন। ব্যানার আর promo.js যোগ হলো। বাজারঘরের সব functional test (পর্ব ৩৬-এর Playwright test-সহ) সবুজ, কারণ পাতা ঠিকঠাক কাজ করে; শুধু ধীর। Functional suite এই ভুল ধরতে পারে না।
  3. Collect. Lighthouse তিনবার: LCP ২৫০৫৮.৯, ২৫০৫৭.৬ আর ২৫০৫৮.০ ms (একটি দশমিকে গোল করা), ওজন প্রতিবার ৪৮৯৪৩৪০ byte.
  4. Median. তিনটি LCP সাজালে মাঝেরটি ২৫০৫৮.০ ms (LHCI লিখেছে ২৫০৫৭.৯৮৭১)। এই lab-এ মানগুলো প্রায় এক, কিন্তু অন্য যন্ত্রে বা আসল নেটওয়ার্কে run-ভেদে পার্থক্য বড় হয়; তাই median.
  5. Assert. LCP > ২৫০০ আর ওজন > ৩০০০০০: দুটি error. ছবির মাপ না দেওয়ায় unsized-images-ও error. TBT আর CLS শূন্য, তাই পাস (§৫-এ দেখেছেন কেন শূন্য হলেও নিশ্চিন্ত নয়)। Score ০.৭২ শুধু সতর্কবার্তা।
  6. Exit code. একটিও error থাকলে exit code 1, CI থামে, merge হয় না। ছবি ছোট আর মাপসহ করে, script-এ defer দিয়ে আবার চালালে gate আবার সবুজ হওয়ার কথা; ঠিক build-এ একই config exit code 0 দিয়েছে।

Absolute budget আর baseline-এর সাথে তুলনা

Budget একটি স্থির সীমা। কিন্তু ধীরে ধীরে ক্ষয়ও বিপদ: প্রতি release-এ ৩০ KB বাড়লে কোনোটিই সীমা ছাড়ায় না, অথচ এক বছরে পাতা দ্বিগুণ। তাই অনেক দল দুটি শর্ত রাখে: সীমার ভেতরে, আর শেষ ভালো build থেকে নির্দিষ্ট শতাংশের বেশি খারাপ নয়। নিচের ব্লকে তা একটি ছোট gate হিসেবে, ব্রাউজারেই Pyodide-এ চলে। Baseline আর “eid-banner” build-এর সংখ্যা ওপরের সত্যিকারের run থেকে; “font-change” build একটি নমুনা: ধরুন কেউ একটি বাংলা web font যোগ করেছেন, আর তিন run-এর একটিতে LCP অস্বাভাবিক বেশি এসেছে।

import statistics

BUDGET = {"lcp_ms": 2500, "bytes": 300_000, "tbt_ms": 200}
TOLERANCE = 0.10          # allowed slowdown against the last good build

# three Lighthouse runs per build (mobile, /products/1), copied from the JSON
baseline = {"lcp_ms": [754.4, 754.6, 755.2], "bytes": [15201] * 3, "tbt_ms": [0] * 3}
builds = {
    "font-change": {"lcp_ms": [812.0, 2950.3, 815.6], "bytes": [61_403] * 3,
                    "tbt_ms": [0, 40, 0]},
    "eid-banner": {"lcp_ms": [25058.9, 25057.6, 25058.0], "bytes": [4_894_340] * 3,
                   "tbt_ms": [0] * 3},
}

def gate(name, runs):
    problems = []
    for metric, limit in BUDGET.items():
        value = statistics.median(runs[metric])
        base = statistics.median(baseline[metric])
        if value > limit:
            problems.append(f"{metric} {value:,.0f} > budget {limit:,}")
        elif base and value > base * (1 + TOLERANCE):
            problems.append(f"{metric} {value:,.0f} is {value / base - 1:+.0%} vs baseline")
    print(f"{name:<12} {'FAIL' if problems else 'PASS'}")
    for p in problems:
        print("   -", p)
    return 1 if problems else 0

codes = [gate(n, r) for n, r in builds.items()]
print("exit code:", max(codes))

আসল আউটপুট:

font-change  FAIL
   - bytes 61,403 is +304% vs baseline
eid-banner   FAIL
   - lcp_ms 25,058 > budget 2,500
   - bytes 4,894,340 > budget 300,000
exit code: 1

“eid-banner” দুটি absolute সীমাই ছাড়িয়েছে, LHCI-র রায়ের সাথে মিল। “font-change”-এর গল্প সূক্ষ্ম। এর ৬১৪০৩ byte ৩০০ KB সীমার অনেক নিচে, কিন্তু baseline-এর চেয়ে +৩০৪%, তাই gate লাল: একটি font পাতার ওজন চার গুণ করেছে, দলের জানা দরকার। LCP-র তিনটি মানের একটি ২৯৫০.৩ ms, যা একা দেখলে budget ভাঙত; কিন্তু median ৮১৫.৬ ms, baseline ৭৫৪.৬-এর চেয়ে মাত্র +৮%, তাই LCP পাস। একটি গোলমেলে run একা gate উল্টায়নি। TBT-র baseline ০, তাই শতাংশের তুলনা বাদ (base and …); শূন্য দিয়ে ভাগ এড়াতে এমন বিশেষ ক্ষেত্র আলাদা ভাবতে হয়। নিজে TOLERANCE ০.০৫ করে চালান: font-change-এর LCP-ও তখন লাল হবে। সীমা কত কড়া হবে, তা noise মেপে ঠিক করতে হয় (পর্ব ৪০)।

৭ · Playwright দিয়ে মাপা — navigation timing আর performance mark

Lighthouse পুরো পাতার একটি রিপোর্ট দেয়, কিন্তু একটি কাজের সময় মাপে না: লগইন করে কার্টে যোগ করার পর badge কত দ্রুত বদলায়? এর জন্য browser-এর নিজের Performance API আছে, যা যেকোনো পাতায় JavaScript থেকে পড়া যায়, আর Playwright (পর্ব ৩৬) সেটি test থেকে পড়তে পারে। তিনটি অংশ কাজে লাগে:

  • Navigation Timing: performance.getEntriesByType('navigation'), পাতা লোডের প্রতিটি ধাপের সময় (TTFB-র জন্য responseStart, domContentLoadedEventEnd, loadEventEnd).
  • PerformanceObserver: LCP, layout shift বা long task-এর মতো ঘটনা ঘটলে জানায়; buffered: true দিলে আগে ঘটে যাওয়াগুলোও দেয়।
  • User Timing: নিজের নাম দেওয়া মুহূর্ত, performance.mark('cart:click'), আর দুই mark-এর মাঝের সময় performance.measure().

Test প্রকল্প পর্ব ৩৬-এর মতো: playwright 1.65.2 আর pytest-playwright 0.10.0 (দুটোই Apache-2.0), pytest 9.2.0, Edge channel, headless; DO_NOT_TRACK=1 রাখা হয়েছিল। ধীর নেটওয়ার্কের জন্য Playwright-এর ভেতর দিয়ে browser-এর CDP (Chrome DevTools Protocol) ব্যবহার হয়েছে, যা শুধু Chromium-গোত্রের browser-এ (Chrome, Edge) চলে। মূল অংশ (পুরো ফাইল আরও একটু লম্বা):

VITALS = """() => new Promise(done => {
  const v = {lcp: 0, cls: 0};
  new PerformanceObserver(l => l.getEntries().forEach(e => v.lcp = e.startTime))
    .observe({type: 'largest-contentful-paint', buffered: true});
  new PerformanceObserver(l => l.getEntries().forEach(e => {
    if (!e.hadRecentInput) v.cls += e.value; }))
    .observe({type: 'layout-shift', buffered: true});
  const n = performance.getEntriesByType('navigation')[0];
  const img = performance.getEntriesByType('resource')
    .filter(r => r.initiatorType === 'img').reduce((s, r) => s + r.encodedBodySize, 0);
  setTimeout(() => done({ttfb: n.responseStart, dcl: n.domContentLoadedEventEnd,
    load: n.loadEventEnd, lcp: v.lcp, cls: v.cls, imgKB: img / 1024}), 300);
})"""

def slow_network(page):                      # CDP: Chromium-family browsers only
    cdp = page.context.new_cdp_session(page)
    cdp.send("Network.emulateNetworkConditions", {"offline": False, "latency": 150,
             "downloadThroughput": 1_600_000 / 8, "uploadThroughput": 750_000 / 8})

def test_product_page_budget(page):
    slow_network(page)
    page.goto("/products/1", wait_until="load")
    m = page.evaluate(VITALS)
    print("\n" + json.dumps({k: round(v, 3 if k == "cls" else 0) for k, v in m.items()}))
    assert m["lcp"] <= 2500, f"LCP {m['lcp']:.0f} ms > 2500 ms"
    assert m["cls"] <= 0.1, f"CLS {m['cls']:.3f} > 0.1"
    assert m["imgKB"] <= 300, f"images {m['imgKB']:.0f} KiB > 300 KiB"

ঠিক build-এ (সত্যিকারের run): {"ttfb": 152.0, "dcl": 398.0, "load": 420.0, "lcp": 452, "cls": 0, "imgKB": 0}, test পাস। ব্যানার build-এ (সত্যিকারের run, ছাঁটা):

{"ttfb": 152.0, "dcl": 795.0, "load": 24925.0, "lcp": 24948, "cls": 0, "imgKB": 4763.0}
F
>       assert m["lcp"] <= 2500, f"LCP {m['lcp']:.0f} ms > 2500 ms"
E       AssertionError: LCP 24948 ms > 2500 ms
FAILED test_frontend_perf.py::test_product_page_budget[chromium] - AssertionE...

একটি assertion ব্যর্থ হলে পরেরগুলো চলে না; তাই ছবির ৪৭৬৩ KiB-এর assertion রিপোর্টে আসেনি, যদিও সেটিও ব্যর্থ হতো। সব মাপ একবারে দেখতে চাইলে প্রথমে সব ভুল একটি তালিকায় জমিয়ে শেষে একবার assert করুন, ঠিক §৬-এর gate-এর মতো।

একটি কাজের সময় — আর মাপার যন্ত্রের ফাঁদ

দ্বিতীয় test: মিতু লগইন করে ডালের পাতায় “কার্টে যোগ করুন” চাপলেন; badge কত দ্রুত বদলায়? বাজারঘর ইচ্ছা করে fetch-এর পর ৪০০ ms দেরিতে badge বদলায় (পর্ব ৩৬-এ দেখেছেন)। প্রথম চেষ্টায় click-এর আগে performance.mark('cart:click'), তারপর Playwright-এর expect(badge).not_to_have_text("0"), তারপর performance.measure(). দ্বিতীয় চেষ্টায় পুরো মাপ পাতার ভেতরে: click-এর মুহূর্তে একটি mark, আর badge বদলানোর মুহূর্তে একটি MutationObserver আরেকটি mark দেয়। দুটোই দুইবার করে (সত্যিকারের run):

click -> badge updated: 872 ms
in-page observer: click -> badge 427 ms
click -> badge updated: 870 ms
in-page observer: click -> badge 429 ms

একই কাজ, দুই রকম ফল, প্রায় দ্বিগুণ পার্থক্য। প্রথম পদ্ধতি পাতার সময় মাপেনি; মেপেছে “Playwright কখন লক্ষ করল”। Web-first assertion (পর্ব ৪০) শর্তটি কিছুক্ষণ পরপর আবার দেখে, মাঝে বিরতি থাকে; badge ৪৩০ ms-এর কাছে বদলালেও পরের যাচাইয়ের সময় পর্যন্ত ধরা পড়েনি (সম্ভবত সেই বিরতিগুলোর যোগফল প্রায় ৮৫০ ms-এর কাছে)। শিক্ষা: সময় মাপতে হলে মুহূর্তটি ঘটনার জায়গায়, পাতার ভেতরে চিহ্নিত করুন; বাইরের polling দিয়ে নয়। আর ৪০০ ms-এর ইচ্ছাকৃত দেরি বাদ দিলে কাজটি নিজে প্রায় ৩০ ms. এক মাপে ১০০০ ms-এর সীমা আরামে পাস, অন্যটিতে প্রায় সীমার কাছে; ভুল যন্ত্রে কড়া সীমা বসালে test অকারণে flaky হতো।

পাতার ভেতরে Performance API — নিজে চালিয়ে দেখুন

নিচের JavaScript ব্লকটি এই পাতারই একটি আলাদা, নিরাপদ iframe-এ চলে। এটি একটি ভারী কাজকে mark দিয়ে মাপে, long task (৫০ ms-এর বেশি main thread দখল) ধরার observer চালায়, আর ৩০০ ms পরে ওপরে একটি “ব্যানার” ঢোকায়, জায়গা না রেখে, যাতে নিচের লেখা সরে যায়। Chromium-গোত্রের browser-এ (Chrome, Edge) সব entry পাওয়া যায়; Firefox আর Safari-তে layout-shift আর longtask নেই বলে দেখাবে (লেখার সময়), যা নিজেই একটি শিক্ষা: field-এ এই মাপ সব ক্রেতার কাছ থেকে আসে না।

const types = PerformanceObserver.supportedEntryTypes;
const canShift = types.includes("layout-shift"), canLong = types.includes("longtask");
console.log("layout-shift supported:", canShift, "| longtask supported:", canLong);
const shifts = [], longs = [];
if (canShift) new PerformanceObserver(l => shifts.push(...l.getEntries()))
  .observe({ type: "layout-shift", buffered: true });
if (canLong) new PerformanceObserver(l => longs.push(...l.getEntries()))
  .observe({ type: "longtask" });

// 1) a synthetic heavy task, timed with User Timing marks
performance.mark("offer:start");
const until = Date.now() + 120;
while (Date.now() < until) { /* pretend to compute offers */ }
performance.mark("offer:end");
const m = performance.measure("offer", "offer:start", "offer:end");
console.log(`heavy task ≈ ${Math.round(m.duration / 10) * 10} ms`);

// 2) a late banner with no reserved space pushes the content down
setTimeout(() => {
  const b = document.createElement("div");
  b.style.cssText = "height:60px;background:#fde68a";
  b.textContent = "ঈদের অফার!";
  document.body.prepend(b);
}, 300);

setTimeout(() => {
  console.log("long tasks seen:", longs.length);
  console.log("layout shifts seen:", shifts.length);
  for (const e of shifts)
    console.log(`  value ${e.value.toFixed(2)} · after input: ${e.hadRecentInput}`);
}, 900);

আসল আউটপুট (headless Edge-এ):

layout-shift supported: true | longtask supported: true
heavy task ≈ 120 ms
long tasks seen: 1
layout shifts seen: 1
  value 0.05 · after input: false

User Timing-এর দুই mark-এর মাঝে ভারী কাজটি ≈ ১২০ ms, আর long task-এর observer একটি entry পেয়েছে, কারণ কাজটি ৫০ ms-এর বেশি main thread দখল করেছে। ৩০০ ms পরে জায়গা না রেখে ঢোকানো “ব্যানার” নিচের তিনটি লাইনকে ৬০ px নামিয়েছে, আর browser একটি layout shift লিখেছে, ইনপুট ছাড়া (after input: false), তাই এটি CLS-এ গোনা হবে। Shift-এর মান (এখানে ০.০৫) iframe-এর মাপের ওপর নির্ভর করে: যত বড় অংশ সরে আর যত দূর সরে, score তত বেশি; তাই আপনার পর্দায় মান একটু আলাদা আসতে পারে। Firefox বা Safari-তে প্রথম লাইনে false দেখলে বুঝবেন, সেই browser-এর ক্রেতাদের কাছ থেকে field-এ এই মাপ আসবে না। নিজে ব্যানারের height আগে থেকে রাখা একটি খালি জায়গায় বসান (যেমন data-html-এ ৬০ px-এর একটি div রেখে তার ভেতরে লেখা দিন): তখন কিছু সরবে না, shift-এর সংখ্যা ০.

৮ · CLS-এর হিসাব, আর font, ছবি, cache ও JS-এর যাচাই

CLS কীভাবে জোড়া হয়

প্রতিটি layout shift-এর একটি score থাকে: কতটা জায়গা জুড়ে সরল আর কত দূর সরল, তার গুণফল। কিন্তু CLS সব score-এর সরল যোগফল নয়। Shift-গুলোকে দলে ভাগ করা হয়, যাকে বলে session window: পরপর দুটি shift-এর মাঝে ১ সেকেন্ডের কম ফাঁক থাকলে একই দলে, আর একটি দল সর্বোচ্চ ৫ সেকেন্ড লম্বা। CLS = সবচেয়ে বড় দলের যোগফল। আর ব্যবহারকারীর ইনপুটের ঠিক পরের shift (hadRecentInput) বাদ যায়, কারণ “আরও দেখুন” চাপলে কিছু সরবে, সেটাই প্রত্যাশিত। নিচের ব্লকে এই নিয়ম একটি function, আর তিনটি রেকর্ড করা shift-এর তালিকায় (নমুনা data) budget test; test_late_banner ইচ্ছা করে লাল।

import sys, unittest

def cls(shifts):            # shifts: (time_ms, score, had_recent_input)
    best = cur = 0.0
    start = last = None
    for t, v, user in sorted(shifts):
        if user:                                   # right after input: ignored
            continue
        if last is None or t - last >= 1000 or t - start > 5000:
            start, cur = t, 0.0                    # open a new session window
        cur += v
        last = t
        best = max(best, cur)
    return round(best, 4)

# recorded layout-shift entries (sample data, product page)
late_banner = [(1200, 0.08, False), (1500, 0.05, False), (4100, 0.03, False)]
ad_twice = [(3000, 0.06, False), (3400, 0.02, False),
            (9000, 0.07, False), (9300, 0.02, False)]
after_click = [(2000, 0.04, False), (6000, 0.30, True)]
for name, s in (("late_banner", late_banner), ("ad_twice", ad_twice),
                ("after_click", after_click)):
    total = round(sum(v for _, v, _ in s), 4)
    print(f"{name:<12} sum of all = {total:<5} CLS = {cls(s)}")

class ClsBudget(unittest.TestCase):
    def test_late_banner(self):
        self.assertLessEqual(cls(late_banner), 0.1)
    def test_ad_twice(self):
        self.assertLessEqual(cls(ad_twice), 0.1)
    def test_input_shift_ignored(self):
        self.assertEqual(cls(after_click), 0.04)

suite = unittest.defaultTestLoader.loadTestsFromTestCase(ClsBudget)
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)

আসল আউটপুট:

late_banner  sum of all = 0.16  CLS = 0.13
ad_twice     sum of all = 0.17  CLS = 0.09
after_click  sum of all = 0.34  CLS = 0.04
test_ad_twice (__main__.ClsBudget.test_ad_twice) ... ok
test_input_shift_ignored (__main__.ClsBudget.test_input_shift_ignored) ... ok
test_late_banner (__main__.ClsBudget.test_late_banner) ... FAIL

======================================================================
FAIL: test_late_banner (__main__.ClsBudget.test_late_banner)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 28, in test_late_banner
    self.assertLessEqual(cls(late_banner), 0.1)
    ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: 0.13 not less than or equal to 0.1

----------------------------------------------------------------------
Ran 3 tests in 0.001s

FAILED (failures=1)

“late_banner”-এ প্রথম দুটি shift ৩০০ ms ফাঁকে, একই দলে: ০.০৮ + ০.০৫ = ০.১৩; তৃতীয়টি ২৬০০ ms পরে, নতুন দল। CLS ০.১৩, সীমা ০.১ ছাড়াল, তাই test_late_banner লাল (unittest নাম অনুযায়ী সাজিয়ে চালায়, তাই রিপোর্টে এটি শেষে), আর বার্তা সরাসরি বলে 0.13 not less than or equal to 0.1. “ad_twice”-এর সব shift যোগ করলে ০.১৭, সরল যোগে ব্যর্থ মনে হতো; কিন্তু দুটি দল আলাদা (৫৬০০ ms ফাঁক), বড়টি ০.০৯, তাই পাস। এভাবে লম্বা সময় খোলা থাকা পাতা (যেমন একটি single-page app) ছোট ছোট shift জমিয়ে অন্যায়ভাবে শাস্তি পায় না। “after_click”-এ ক্লিকের পরের বড় ০.৩০ shift বাদ গেছে। নিজের CLS test লিখতে গেলে এই দুটি নিয়ম (দল আর ইনপুট) ভুল হওয়ার ঝুঁকিই সবচেয়ে বেশি; সম্ভব হলে নিজে হিসাব না করে browser বা পরিচিত library-র মান ব্যবহার করুন, আর এমন হাতে-হিসাব শুধু শেখার জন্য।

বাংলা web font — খরচ আর যাচাই

ইংরেজি font-এর তুলনায় বাংলা font-এ glyph অনেক বেশি: যুক্তাক্ষর, কার আর ফলার নানা রূপ। তাই বাংলা web font-এর ফাইল সাধারণত ভারী, আর একাধিক weight (৪০০, ৬০০, ৭০০) যোগ করলে খরচ গুণ হয়। Font না আসা পর্যন্ত browser লেখা লুকাতে পারে (অদৃশ্য লেখা), অথবা অন্য font-এ দেখিয়ে পরে বদলাতে পারে, তাতে লেখার চওড়া বদলে লাফ (CLS). বাজারঘর এখন কোনো web font নামায় না, ফোনের নিজের বাংলা font ব্যবহার করে; তাই ওপরের run-গুলোতে font-এর খরচ শূন্য। Web font যোগ হলে tester যা যাচাই করবেন:

  • @font-face-এ font-display আছে কি (সাধারণত swap), যাতে লেখা অদৃশ্য না থাকে; Lighthouse-এর font-display-insight এটি দেখে।
  • Subsetting আর unicode-range: বাংলা আর লাতিন অংশ আলাদা ফাইলে, যাতে শুধু ইংরেজি পাতায় বাংলা ফাইল না নামে।
  • কয়টি weight আর কত KB, পাতার ওজনের budget-এ ধরা আছে কি; Network-এ font ফাইল কয়টি নামছে।
  • Font বদলের মুহূর্তে লেআউট সরে কি না: ধীর নেটওয়ার্কে (§৭-এর CDP) Playwright দিয়ে CLS মাপা।

Font বদলালে engine-ভেদে লেখার মাপ কীভাবে বদলায়, তা পর্ব ৪২-এ সত্যিকারের মাপে দেখেছেন; font বানানো আর লোড করার কৌশল HTML ও CSS কোর্সের পর্ব ২১-এ; বাংলা লেখার পূর্ণ localization testing পর্ব ৫৬-এ (Localization testing) আসবে।

Cache header — নিজে দেখুন

Lighthouse-এর “Use efficient cache lifetimes” নিজে যাচাই করতে curl -I যথেষ্ট (সত্যিকারের run, তারিখ আর CSP-র লাইন বাদ):

$ curl -sI http://127.0.0.1:8826/static/app.css
HTTP/1.1 200 OK
server: uvicorn
content-type: text/css; charset=utf-8
content-length: 4257
last-modified: Mon, 16 Nov 2026 13:09:23 GMT
etag: "137658a652fe1c5a395fe9b2291b5bc4"
x-content-type-options: nosniff

etag আর last-modified আছে, তাই browser পরের বার “বদলেছে কি?” জিজ্ঞেস করে 304 পেতে পারে; কিন্তু Cache-Control নেই, তাই কতক্ষণ না জিজ্ঞেস করেই রাখা যাবে, বলা নেই। প্রতি পাতায় অন্তত একটি ছোট অনুরোধ বাড়তি। নামে hash থাকা স্থির ফাইলে লম্বা সময়ের cache আর HTML-এ ছোট বা revalidate, এই নকশার ব্যাখ্যা ফুল-স্ট্যাক কোর্সের পর্ব ৮৪-এ আছে। Tester-এর কাজ: প্রতিটি ধরনের ফাইলের header-এর একটি প্রত্যাশিত table রাখা, আর একটি ছোট test দিয়ে মেলানো।

JavaScript-এর আকার

ব্যানার build-এ ৩৫০ ms-এর ছোট্ট promo.js মোবাইলে “JavaScript execution time 1.4 s” হয়ে দেখা দিল, কারণ Lighthouse-এর মোবাইল মোড CPU চার গুণ ধীর ধরে। আসল সাইটে JavaScript-ই প্রায়ই সবচেয়ে বড় CPU-খরচ: নামানো, পড়া, চালানো। তাই budget-এ শুধু মোট ওজন নয়, script-এর ওজনও আলাদা রাখা যায় (LHCI-তে resource-summary:script:size-এর মতো assertion; নাম আর রূপ নিজের version-এর নথিতে মিলিয়ে নেবেন)। Bundle ছোট রাখার কৌশল ফুল-স্ট্যাক কোর্সের পর্ব ৭৯-এ।

আরও গভীরে: Lab-এর মাপ কম noisy করতে Lighthouse দুই ধরনের throttling দেয়: simulate (দ্রুত চালিয়ে মডেলে হিসাব, ডিফল্ট) আর devtools (browser-কে সত্যিই ধীর করা)। Simulate স্থির কিন্তু অনুমান, devtools বাস্তবের কাছাকাছি কিন্তু run-ভেদে বেশি দোলে; Lighthouse-এর নথি variability নিয়ে আলাদা লেখা রেখেছে, যার মূল পরামর্শ একাধিক run আর median. Field-এ বড় দলগুলো LCP-র মতো মাপ ভাগ করে দেখে (TTFB, resource load delay, load duration, render delay), যাতে কোন ধাপ ধীর তা আলাদা হয়; Lighthouse 13-এর lcp-breakdown-insight lab-এ ঠিক এই ভাগ দেখায়। আর পরীক্ষামূলক A/B তুলনায় performance-এর প্রভাব মাপার পরিসংখ্যান মেশিন লার্নিং কোর্সের A/B test-এর পর্বগুলোর মতোই।

পরীক্ষা ও ইন্টারভিউতে:

  • Core Web Vitals কী কী, সীমা? LCP ≤ ২.৫ s, INP ≤ ২০০ ms, CLS ≤ ০.১; আসল page view-এর 75th percentile ধরে।
  • Lab আর field data-র পার্থক্য? Lab নিয়ন্ত্রিত, পুনরাবৃত্তিযোগ্য, তুলনা আর gate-এর জন্য; field আসল ক্রেতার, রায়ের জন্য।
  • Lighthouse INP দেয় না কেন? Lab-এ কেউ ক্লিক করেন না; কাছাকাছি সংকেত হিসেবে TBT.
  • Performance budget কী? সংখ্যায় লেখা সীমা (ওজন, LCP…), যা ছাড়ালে CI-তে build থামে।
  • একবারের run-এ gate কেন নয়? মাপে noise থাকে; কয়েকটি run-এর median আর baseline-এর সাথে tolerance.

৯ · AI-এর যুগে — AI দিয়ে performance test আর পরামর্শ

AI সহকারীকে “পণ্যের পাতার জন্য performance test লিখে দাও” বললে চেনা ভুলগুলো আসে: শুধু desktop-এ, throttling ছাড়া মাপা, তাই সব সবুজ; একটিমাত্র run; sleep(3) দিয়ে “লোড শেষের” অপেক্ষা; score ১০০-কে লক্ষ্য বানানো; Lighthouse-এর এমন flag (যেমন পুরোনো --budget-path), যা আপনার version-এ নেই; INP lab-এ মাপার দাবি; বা expect-এর polling দিয়ে সময় মাপা, যা §৭-এ দেখলেন প্রায় দ্বিগুণ দেখায়। আরও আছে: AI রিপোর্টের পুরো JSON কোথাও পেস্ট করতে বলতে পারে, যাতে যন্ত্রের তথ্য থাকে; অথবা না চালিয়েই “LCP এখন ১.২ s” ধাঁচের দাবি।

AI-কে স্পষ্ট শর্ত দিন, আর যাচাই নিজের হাতে রাখুন:

তুমি একজন অভিজ্ঞ QA engineer. বাজারঘরের (আমার নিজের app, শুধু http://127.0.0.1:8826) পণ্যের পাতার জন্য Lighthouse CI-র lighthouserc.json আর একটি pytest-playwright test লিখবে। শর্ত: ১. Requirement: মোবাইল lab-এ ৩টি run-এর median LCP ≤ 2500 ms, TBT ≤ 200 ms, CLS ≤ 0.1, পাতার মোট ওজন ≤ 300000 byte. Score শুধু সতর্কবার্তা। ২. Lighthouse 13.6.0 আর @lhci/cli 0.16.1 ব্যবহার করছি। যে option লিখবে, তার নাম official নথির কোথায় আছে বলবে; নিশ্চিত না হলে বলবে। ৩. কোনো upload ধাপ থাকবে না; error reporting বন্ধ। ৪. Playwright test-এ সময় মাপবে পাতার ভেতরে performance.mark আর PerformanceObserver দিয়ে; sleep বা expect-এর polling দিয়ে নয়। ৫. Lab-এ INP মাপা যায় না, এটা মনে রেখে INP-এর জন্য কী প্রস্তাব করবে, আলাদা লিখবে। ৬. তুমি কিছু চালাওনি; কোনো সংখ্যা বা "পাস করবে" দাবি করবে না।

AI-এর লেখা performance test বা পরামর্শ হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১Server-এর response time ভালো হলেও ব্যবহারকারী পাতা ধীর পান — এই ধারণা কোথা থেকে এল, আর tester-এর পরিকল্পনায় এর প্রভাব কী?

২০০৭ সালে Steve Souders, তখন Yahoo!-তে performance নিয়ে কাজ করতেন, “High Performance Web Sites” বইয়ে একটি পর্যবেক্ষণ জনপ্রিয় করেন, যাকে তিনি performance-এর “golden rule” বলেছিলেন: ব্যবহারকারীর অপেক্ষার বেশিরভাগ সময়, তাঁর মাপে প্রায় ৮০ থেকে ৯০ শতাংশ, যায় frontend-এ: HTML আসার পরে ছবি, CSS, script নামানো আর চালানোয়। সংখ্যাটি তখনকার বড় সাইটগুলোর মাপ থেকে; আজকের প্রতিটি সাইটে হুবহু খাটবে, এমন নয়। কিন্তু দিকটি এখনো সত্য, আর এই পর্বের lab-ই উদাহরণ: পণ্যের পাতার HTML server কয়েক মিলিসেকেন্ডে দেয়, অথচ ব্যানার build-এ LCP ২৫ সেকেন্ড।

Souders পরে ২০১০ সালে HTTP Archive শুরু করেন, যা নিয়মিত লাখো পাতার গঠন (ওজন, অনুরোধের সংখ্যা, script-এর পরিমাণ) মেপে প্রকাশ করে। এই ধরনের মাপ থেকে বারবার দেখা গেছে, পাতার ওজন আর JavaScript সময়ের সাথে বেড়েছে, যদিও নেটওয়ার্কও দ্রুত হয়েছে।

Tester-এর পরিকল্পনায় এর তিনটি প্রভাব। এক, শুধু backend load test দিয়ে “performance-এ পাস” বলা যায় না; পর্ব ৪৬-৫০-এর server test আর এই পর্বের browser test, দুটোই লাগে, আর দুটির সীমাও আলাদা স্তরে লেখা হয়। দুই, frontend-এর ভুল প্রায়ই কোনো functional test ভাঙায় না: ব্যানার build-এ বাজারঘরের সব UI test সবুজ ছিল। তাই performance budget আলাদা gate হিসেবে না থাকলে এমন পরিবর্তন সহজেই production-এ যায়। তিন, frontend-এর পরিবর্তন প্রায়ই developer-এর বাইরে থেকে আসে: মার্কেটিং-এর ব্যানার, analytics-এর script, chat widget. এগুলোর জন্যও একই gate থাকা দরকার, কারণ ক্রেতার কাছে ধীরগতির উৎস আলাদা নয়।

মূল উপলব্ধি: ক্রেতার অপেক্ষার বড় অংশ browser-এর ভেতরে কাটে; server দ্রুত দেখে নিশ্চিন্ত না হয়ে পাতার স্তরে মাপুন, আর সব উৎসের পরিবর্তনকে একই budget-এর আওতায় আনুন।

প্র ০২FID থেকে INP-এ বদল কেন হলো, আর মাপের সংজ্ঞা বদলালে একটি দলের test আর gate-এর কী হয়?

Google ২০২০ সালে Core Web Vitals ঘোষণা করে; সাড়ার মাপ ছিল FID, First Input Delay. FID মাপত শুধু প্রথম ইনপুট আর browser-এর সেই ইনপুট সামলানো শুরুর মাঝের অপেক্ষা। দুটি বড় ফাঁক ছিল: প্রথম ক্লিকের পরের ক্লিকগুলো গোনা হতো না, আর ক্লিকের handler কতক্ষণ চলল আর পর্দায় ফল কখন আঁকা হলো, তা-ও না। ফলে অনেক সাইট FID-এ “ভালো” থাকত, অথচ ক্রেতারা কার্টে যোগের পর বোতাম আটকে থাকা দেখতেন।

Chrome দল ২০২২ সালের দিকে পরীক্ষামূলক মাপ হিসেবে INP আনে, আর ২০২৪ সালের মার্চে INP স্থায়ীভাবে FID-এর জায়গা নেয় বলে ঘোষণা করে। INP পুরো ভিজিটের প্রায় সবচেয়ে খারাপ interaction ধরে, অপেক্ষা থেকে পরের আঁকা পর্যন্ত। এর আগেও সংজ্ঞা বদলেছিল: CLS প্রথমে পুরো পাতার জীবনের সব shift যোগ করত, ২০২১ সালের দিকে session window-ভিত্তিক হয়, যাতে দীর্ঘ সময় খোলা থাকা পাতা অন্যায় শাস্তি না পায়।

দলের জন্য এর প্রভাব বাস্তব। পুরোনো dashboard আর gate হঠাৎ অর্থ হারায়: FID-এর ওপর লেখা সীমা INP-তে খাটে না, সংখ্যার মাপকাঠিই আলাদা। একই পাতা কোনো পরিবর্তন ছাড়াই “ভালো” থেকে “উন্নতি দরকার”-এ যেতে পারে। Tool-এর version বদলালেও মান বদলায়: Lighthouse-এর score-এর ওজন বিভিন্ন version-এ আলাদা ছিল, আর নতুন version-এ পুরোনো budget option-ই সরানো হয়েছে, যা এই পর্বে LHCI দিয়ে প্রতিস্থাপন করতে হলো।

তাই ভালো অভ্যাস: test-এর রিপোর্টে মাপের নাম, সংজ্ঞার উৎস আর tool-এর হুবহু version লেখা; version pin করা (এই পর্বে --save-exact); version বদলালে আগে পুরোনো আর নতুন দুটি দিয়ে একই build মেপে baseline নতুন করে ঠিক করা; আর web.dev-এর মতো প্রাথমিক উৎসের পরিবর্তন-ঘোষণার খোঁজ রাখা। পর্ব ৪০-এর মতো এখানেও ভুল সতর্কবার্তার ঝুঁকি আছে: version বদলের দিনের লাল gate কোডের দোষ না-ও হতে পারে।

মূল উপলব্ধি: Performance-এর মাপ চিরস্থায়ী সত্য নয়, একটি সংজ্ঞা; সংজ্ঞা আর tool-এর version লিখে রাখুন, pin করুন, আর বদলের সময় baseline নতুন করে মাপুন।

প্র ০৩Lighthouse-এ ১০০ পেয়েছেন, অথচ ক্রেতারা বলছেন সাইট ধীর। কে ভুল, আর একজন tester কীভাবে মীমাংসা করবেন?

সম্ভবত কেউই ভুল নন; দুই পক্ষ দুটি আলাদা জিনিস মেপেছেন। Lighthouse একটি নির্দিষ্ট নকল ফোনে, একটি নির্দিষ্ট নকল নেটওয়ার্কে, একটি খালি cache নিয়ে, একবার পাতা খোলে। কেউ ক্লিক করেন না, তাই INP মাপাই হয় না। ক্রেতারা আসল ফোনে, আসল নেটওয়ার্কে, লগইন করা অবস্থায়, কার্টে জিনিস নিয়ে, বারবার ক্লিক করেন। এই পর্বের ছোট উদাহরণে lab-এ ঠিক build-এর LCP ০.৮ s, আর আটটি নমুনা field মানের p75 ২.৭ s.

পার্থক্যের সাধারণ উৎস কয়েকটি। ডিভাইস: Lighthouse-এর CPU-ধীরতা একটি অনুমান; সস্তা ফোনের আসল ধীরতা আলাদা হতে পারে। নেটওয়ার্ক: লিফট, গ্রামের দুর্বল সিগন্যাল, ভিড়ের সময়ের মোবাইল নেটওয়ার্ক। পাতার অবস্থা: lab সাধারণত লগইন ছাড়া মাপে, অথচ লগইন করা ক্রেতার পাতায় সুপারিশ, কার্ট আর ব্যক্তিগত অংশ থাকে। Third-party: বিজ্ঞাপন আর analytics production-এ থাকে, test environment-এ প্রায়ই থাকে না। আর ইনপুট: ধীর click handler lab-এর TBT-তে দেখা না-ও যেতে পারে।

মীমাংসার পথ ধাপে ধাপে। প্রথমে field data সংগ্রহ নিশ্চিত করা: RUM দিয়ে LCP, INP আর CLS, ডিভাইস আর পাতার ধরন অনুযায়ী ভাগ করে (CrUX থাকলে সেটিও দেখা)। তারপর কোন মাপ, কোন পাতা, কোন ডিভাইসের দল খারাপ, খুঁজে বের করা। তারপর lab-এ সেই অবস্থা যতটা সম্ভব নকল করা: সেই পাতা, লগইন অবস্থা, Playwright-এ CDP দিয়ে ধীর নেটওয়ার্ক আর CPU, আর আসল interaction চালিয়ে performance mark দিয়ে মাপা। ভুল lab-এ পুনরুৎপাদন করা গেলে তবেই সমাধান মেপে যাচাই করা যায়। শেষে field-এ আবার দেখা, সমাধানের পর p75 সত্যিই নামল কি না।

এই প্রশ্নের একটি সাংগঠনিক দিকও আছে: যে দল শুধু lab score-কে লক্ষ্য বানায়, সে score বাড়ানোর কৌশল শেখে (যেমন lab-এ না আসা জিনিস দেরিতে লোড), ক্রেতার অভিজ্ঞতা নয়। পর্ব ৪৬-এর প্রক্রিয়ার মতো, লক্ষ্য লিখুন field-এর percentile-এ, আর lab-কে ব্যবহার করুন সেই লক্ষ্যের পাহারাদার হিসেবে।

মূল উপলব্ধি: Lab score হলো নিয়ন্ত্রিত পরীক্ষার ফল, ক্রেতার রায় নয়; field দিয়ে সমস্যা চিনুন, lab-এ পুনরুৎপাদন করে সমাধান মাপুন, আর আবার field দিয়ে নিশ্চিত হোন।

প্র ০৪Performance-এর lab মাপে noise থাকে। CI-তে এমন gate কীভাবে বানাবেন, যা আসল regression ধরে কিন্তু অকারণে লাল হয় না?

সমস্যাটি পর্ব ৪০-এর flaky test-এর আত্মীয়। একটি functional test-এ উত্তর হ্যাঁ বা না; performance-এ উত্তর একটি সংখ্যা, যা একই কোডে run-ভেদে বদলায়: CPU-র অন্য কাজ, নেটওয়ার্ক, cache, এমনকি বিদ্যুৎ সাশ্রয়ের মোড। এই পর্বের lab-এ simulate-মোডের Lighthouse তিন run-এ প্রায় হুবহু এক মান দিয়েছে (৭৫৪.৪, ৭৫৪.৬, ৭৫৫.২ ms), কারণ মডেল হিসাব করে; কিন্তু ফুল-স্ট্যাক কোর্সের পর্ব ৮৪-এর lab-এ একই পাতার LCP একবার ২.৬ আর দুবার ৬.৫ s এসেছিল, lazy ছবি কখন খোঁজা হয় তার ওপর নির্ভর করে।

ভালো gate-এর কয়েকটি উপাদান। এক, একাধিক run আর একটি সারাংশ: median একটি অস্বাভাবিক run-কে উপেক্ষা করে; এই পর্বের নমুনা “font-change” build-এর ২৯৫০ ms-এর run একা gate উল্টায়নি। দুই, দুই রকম শর্ত: absolute budget বড় ভাঙন ধরে, baseline-এর সাথে শতাংশের tolerance ধীর ক্ষয় ধরে। তিন, tolerance ঠিক করা মেপে: একই build বেশ কয়েকবার চালিয়ে দেখা মাপ স্বাভাবিকভাবে কতটা দোলে, তারপর তার চেয়ে বড় পার্থক্যকেই regression বলা। চার, যন্ত্র স্থির রাখা: একই runner, একই browser version, অন্য ভারী কাজ ছাড়া। পাঁচ, অর্থবহ মাপ বাছাই: byte-এর মতো নির্ধারিত মাপ (৩ run-এ ৪৮৯৪৩৪০, ৪৮৯৪৩৪০, ৪৮৯৪৩৪০) প্রায় noise-মুক্ত, তাই কড়া সীমা চলে; সময়ের মাপে ঢিলা সীমা লাগে।

বড় প্রকল্পে আরও পরিসংখ্যান ব্যবহার হয়: অনেক run নিয়ে দুই build-এর বণ্টন তুলনা, বা সময়ের ধারায় হঠাৎ ধাপ বদল (change point) খোঁজা। Web-এর জন্য WebPageTest-এর মতো tool-এ একই পাতা অনেকবার মেপে median নেওয়ার অভ্যাস বহু বছর ধরে প্রচলিত। আর gate লাল হলে সিদ্ধান্তের পথ লেখা থাকা দরকার: আবার চালানো কতবার চলবে, কে baseline বদলানোর অনুমতি দেবেন, কবে budget ইচ্ছা করে বাড়ানো যাবে (যেমন একটি নতুন, দরকারি feature-এর জন্য)।

মূল উপলব্ধি: Performance gate একটি পরিসংখ্যানের সিদ্ধান্ত: একাধিক run, median, absolute সীমা আর মাপা noise-এর ভিত্তিতে tolerance; নির্ধারিত মাপে কড়া, সময়ের মাপে সহনশীল।

প্র ০৫বাংলা সাইটের performance testing-এ font কেন বিশেষ মনোযোগ চায়, আর web font ব্যবস্থার ইতিহাস থেকে tester কী শিখতে পারেন?

Web-এ নিজের font পাঠানোর ব্যবস্থা @font-face প্রথম আসে ১৯৯০-এর দশকের শেষে CSS2-তে, কিন্তু browser-গুলোর সমর্থন আর font-এর লাইসেন্সের জটিলতায় তা ব্যাপক হয় ২০১০ সালের আশেপাশে, যখন WOFF ফরম্যাট আর বড় font সেবাগুলো চালু হয়। তারপর থেকে একটি নতুন সমস্যা: font না আসা পর্যন্ত লেখা দেখাব কি না। কিছু browser কয়েক সেকেন্ড লেখা লুকিয়ে রাখত, যাকে বলা হতো FOIT (flash of invisible text); অন্যরা আগে fallback দেখিয়ে পরে বদলাত, FOUT. CSS Fonts Level 4-এর font-display এই আচরণ নিয়ন্ত্রণ করার ক্ষমতা লেখকের হাতে দেয়।

বাংলার ক্ষেত্রে সমস্যা বড় হয় কয়েকটি কারণে। এক, glyph বেশি: স্বর, ব্যঞ্জন, কার, ফলা আর শত শত যুক্তাক্ষর, তার সাথে shaping-এর নিয়ম; ফাইল তাই লাতিন font-এর চেয়ে সাধারণত অনেক ভারী। দুই, fallback-এর ঝুঁকি: ফোনে কোন বাংলা font আছে, তা ঠিক নেই; পর্ব ৪২-এ দেখেছেন font বদলালে একই লেখার চওড়া বদলায়, তাই font বদলের মুহূর্তে লাইন ভাঙা আর উচ্চতা বদলে CLS হতে পারে। তিন, পাঠকের নেটওয়ার্ক: বাংলা সাইটের বড় অংশ পড়েন মোবাইল ডেটায়, যেখানে প্রতিটি অতিরিক্ত weight আসল খরচ।

Tester-এর শিক্ষা তিনটি। প্রথমত, font একটি resource, তাই budget-এর অংশ: কয়টি ফাইল, কত KB, কোন পাতায়। দ্বিতীয়ত, font-এর আচরণ দেখতে ধীর নেটওয়ার্কে test চাই: দ্রুত localhost-এ font তৎক্ষণাৎ আসে, FOIT বা লাফ কখনো দেখা যায় না, যেমন এই পর্বের lab-এ ব্যানারের CLS দেখা যায়নি। তৃতীয়ত, subsetting-এর ফাঁদ: শুধু ব্যবহৃত অক্ষর রেখে ফাইল ছোট করলে নতুন কোনো পণ্যের নামে একটি যুক্তাক্ষর বাদ পড়তে পারে, আর তা ভাঙা বা fallback-এ দেখায়। তাই subset করা font-এ সব যুক্তাক্ষরের একটি test-পাতা রাখা দরকার, যা পর্ব ৫৬-এ (Localization testing) আরও বিস্তারে আসবে।

মূল উপলব্ধি: বাংলা web font একসাথে ওজন, দেরি আর লেআউটের ঝুঁকি; budget-এ ধরুন, ধীর নেটওয়ার্কে দেখুন, আর subset করা font-এ যুক্তাক্ষর ঠিক আছে কি না যাচাই করুন।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন।

  1. Spec থেকে test ডিজাইন: চেকআউট পাতার requirement: “মোবাইলে p75 LCP ≤ ২.৫ s আর CLS ≤ ০.১; পাতার মোট ওজন ≤ ৩০০ KB; ‘অর্ডার দিন’ চাপার পর ১ সেকেন্ডের মধ্যে অপেক্ষার চিহ্ন দেখা যাবে।” (ক) কোন অংশ lab-এ, কোন অংশ field-এ যাচাই করবেন, কোন tool দিয়ে? (খ) ওজনের সীমার boundary test-এর মান কী কী? (গ) “১ সেকেন্ড” কীভাবে মাপবেন যাতে মাপার যন্ত্রের ভুল না ঢোকে?

    (ক) p75-এর অংশ field-এর, RUM দিয়ে (মোবাইল আলাদা করে); release আটকাতে একই মাপের lab রূপ: LHCI-তে মোবাইল, ৩ run-এর median LCP ≤ ২৫০০ ms আর CLS ≤ ০.১. ওজন lab-এ নির্ধারিত মাপ, LHCI-র total-byte-weight. অপেক্ষার চিহ্ন একটি interaction, তাই Playwright test. (খ) “৩০০ KB” আগে স্পষ্ট করুন: ৩০০০০০ byte নাকি ৩০০ × ১০২৪? ধরলেন ৩০০০০০ byte হলে boundary: ২৯৯৯৯৯ (পাস), ৩০০০০০ (পাস, কারণ “≤”), ৩০০০০১ (ফেল); অনুশীলনে সহজ উপায় হলো একটি পরীক্ষামূলক ছবির আকার বদলে পাতাকে ওই মানগুলোর কাছে নেওয়া, অথবা gate-এর function-কে সরাসরি এই মান দিয়ে unit test করা। (গ) Click-এর মুহূর্তে পাতার ভেতরে performance.mark, আর চিহ্নটি দেখা দেওয়ার মুহূর্তে MutationObserver থেকে আরেকটি mark; তারপর performance.measure. Playwright-এর expect-এর polling দিয়ে মাপবেন না, আর ধীর নেটওয়ার্ক ও CPU-তে আলাদা run রাখুন।

  2. Failure পড়ুন আর অনুমান করুন: একটি CI run-এ এই আউটপুট এল:
    ×  largest-contentful-paint failure for maxNumericValue assertion
          expected: <=2500   found: 25057.9871
    ×  total-byte-weight failure for maxNumericValue assertion
          expected: <=300000 found: 4894340
    ✓  total-blocking-time   (found: 0)
    Assertion failed. Exiting with status code 1.
    (ক) পরিবর্তনটি সম্ভবত কী ধরনের? (খ) Developer বললেন “TBT শূন্য, তাই script-এর কোনো দোষ নেই।” ঠিক কি? (গ) ছবি ঠিক করার পরও কোন অবস্থায় LCP ব্যর্থ থাকতে পারে?

    (ক) প্রায় ৪.৭ MB ওজন বেড়েছে আর LCP প্রায় ২৫ s: একটি বড় resource, সম্ভবত একটি অপ্টিমাইজ না করা ছবি, যা LCP element-ও হয়েছে। ১.৬ Mbps-এ ৪৭৮০ KiB নামাতে প্রায় ২৩.৯ s লাগে, সংখ্যাগুলো মেলে। (খ) ঠিক নয়। TBT শুধু FCP-র পরের আটকানো সময় গোনে; head-এর একটি সাধারণ script প্রথম আঁকার আগে চলে, তার খরচ FCP-তে পড়ে। FCP, “render-blocking requests” আর “JavaScript execution time” দেখুন। (গ) Head-এ render-blocking script বা CSS থাকলে, ছবি দেরিতে খোঁজা হলে (যেমন LCP ছবিতে loading="lazy"), বা server ধীর হলে; LHCI-র রিপোর্টে lcp-breakdown-insight আর lcp-discovery-insight দেখে কোন ভাগে সময় যাচ্ছে বুঝুন, তারপর আবার একই config-এ মাপুন।

  3. এই test-এ ভুল খুঁজুন: একজন সহকর্মীর লেখা Playwright test; অন্তত পাঁচটি সমস্যা খুঁজুন।
    def test_product_page_fast(page):
        t0 = time.time()
        page.goto("http://127.0.0.1:8826/products/1")
        time.sleep(3)                      # wait for everything
        expect(page.get_by_test_id("product-title")).to_be_visible()
        ms = (time.time() - t0) * 1000
        assert ms < 5000                   # page is fast
        # TODO: maybe check on mobile later

    (১) time.sleep(3) মাপের ভেতরে ঢুকেছে, তাই ms সব সময় অন্তত ৩০০০; পাতা যত দ্রুতই হোক। (২) সময় মাপা হচ্ছে test-এর বাইরের ঘড়িতে, পাতার নিজের মুহূর্ত (LCP, navigation timing) নয়; Playwright-এর নিজের overhead-ও ঢুকছে। (৩) সীমা ৫০০০ ms কোনো requirement থেকে আসেনি; NFR-5-এর মাপ LCP ≤ ২৫০০. আর ৩ s ঘুমের পর ৫ s-এর সীমায় মাত্র ২ s জায়গা, অর্থহীন। (৪) কোনো throttling নেই, desktop-এর মতো দ্রুত localhost-এ মাপা; মোবাইল “পরে” রাখা হয়েছে, অথচ requirement মোবাইলের। (৫) একটিমাত্র run, median নেই। (৬) Visible হওয়া মানে লোড শেষ বা LCP নয়। (৭) CLS আর পাতার ওজন যাচাই নেই। (৮) URL হাতে লেখা, base URL fixture নেই; অন্য environment-এ চালানো কঠিন। (৯) Test-এর নাম আর মন্তব্য দাবি করে “fast”, কিন্তু কোন মাপে, তা বলে না।

  4. CLS হাতে হিসাব: একটি পাতায় এই layout shift-গুলো রেকর্ড হলো (সময় ms, score), কোনোটিই ইনপুটের পরে নয়: (500, 0.03), (900, 0.04), (2500, 0.05), (2800, 0.04), (3100, 0.03). (ক) সব score-এর সরল যোগ কত? (খ) Session window-এর নিয়মে CLS কত? (গ) সীমা ০.১ হলে রায় কী?

    (ক) ০.০৩ + ০.০৪ + ০.০৫ + ০.০৪ + ০.০৩ = ০.১৯. (খ) ৫০০ আর ৯০০-এর ফাঁক ৪০০ ms, একই দল: ০.০৭. ৯০০ থেকে ২৫০০-এর ফাঁক ১৬০০ ms, ১ সেকেন্ডের বেশি, তাই নতুন দল: ২৫০০, ২৮০০, ৩১০০ (ফাঁক ৩০০ ms করে, দলের দৈর্ঘ্য ৬০০ ms, ৫ s-এর কম) = ০.০৫ + ০.০৪ + ০.০৩ = ০.১২. CLS = বড় দল = ০.১২ (§৮-এর function-এ চালিয়ে মেলানো)। (গ) ০.১২ > ০.১, তাই ব্যর্থ, যদিও কোনো একক shift ০.০৫-এর বেশি নয়। দ্বিতীয় দলের shift-গুলো খুঁজুন: সম্ভবত একটি জিনিস একাধিকবার বড় হচ্ছে, যেমন দেরিতে আসা ব্যানার আর তার ভেতরের ছবি।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমCI-তে একটি frontend performance gate-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Requirement থেকে budget লেখা — LCP, CLS, TBT আর পাতার ওজনের সীমা
  2. শেষ ভালো build-এর baseline মাপা
  3. নতুন build-এ একই URL কয়েকবার Lighthouse দিয়ে মাপা
  4. প্রতিটি মাপের median বের করা
  5. Median-কে budget আর baseline-এর সাথে মেলানো
  6. Exit code দিয়ে CI-কে জানানো — 0 হলে এগোনো, 1 হলে থামা

web.dev-এর বর্তমান নির্দেশনা অনুযায়ী INP (Interaction to Next Paint)-এর “ভালো” সীমা কত, আর কোন percentile ধরে বিচার হয়?

  • ≤ 2.5 s, গড় ধরে
  • ≤ 200 ms, 75th percentile ধরে
  • ≤ 0.1, median ধরে
  • ≤ 100 ms, 99th percentile ধরে

একটি পাতার head-এ defer বা async ছাড়া একটি script আছে, যা 350 ms main thread দখল করে। Lighthouse-এর রিপোর্টে TBT = 0 ms. সবচেয়ে সম্ভাব্য ব্যাখ্যা কোনটি?

  • Script আসলে চলেনি
  • Simulate মোডে TBT কখনো মাপা হয় না
  • TBT শুধু FCP-র পরের আটকানো সময় গোনে, আর এই script চলেছে প্রথম আঁকার আগে
  • 350 ms long task হিসেবে গোনার জন্য যথেষ্ট নয়

একটি Lighthouse CI gate-এ LCP-র তিনটি run: 812 ms, 2950 ms, 816 ms. Budget LCP ≤ 2500 ms, aggregationMethod = median. Gate-এর রায় কী?

  • পাস, কারণ median 816 ms
  • ফেল, কারণ একটি run 2950 ms
  • ফেল, কারণ গড় 2500-এর বেশি
  • রায় দেওয়া যায় না, অন্তত ৫টি run লাগে

একটি পাতায় layout shift রেকর্ড হলো (সময় ms, score): (3000, 0.06), (3400, 0.02), (9000, 0.07), (9300, 0.02); কোনোটিই ইনপুটের পরে নয়। Session window-এর নিয়মে (ফাঁক < 1 s, দল ≤ 5 s) CLS কত?

  • 0.17
  • 0.07
  • 0.08
  • 0.09

একটি Playwright test-এ click-এর আগে performance.mark দেওয়া হলো, তারপর expect(badge).not_to_have_text("0") পাস হওয়ার পর performance.measure করা হলো: 870 ms. পাতার ভেতরের MutationObserver দিয়ে একই কাজ মাপলে আসে প্রায় 430 ms. পার্থক্যের কারণ কী?

  • দ্বিতীয়বার cache থাকায় পাতা দ্রুত হয়েছে
  • Expect শর্তটি বিরতি দিয়ে বারবার দেখে, তাই বদলের মুহূর্তের পরে লক্ষ করে
  • performance.mark যথেষ্ট নির্ভুল নয়
  • MutationObserver বদলের আগেই সংকেত দেয়

একটি দলের release gate-এর জন্য performance-এর কোন সিদ্ধান্তটি সবচেয়ে যুক্তিসংগত?

  • Lighthouse score 100 না হলে release বন্ধ
  • Lab-এ মাপা INP ≤ 200 ms হলে release
  • Lab-এ LCP, TBT, CLS আর ওজনের median দিয়ে gate, আর field-এর p75 দিয়ে রায় ও পর্যবেক্ষণ
  • Developer-এর ল্যাপটপে desktop মোডে একবার চালিয়ে দেখা

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. তিনটি প্রশ্ন: LCP (দেখা গেল কখন, ≤ ২.৫ s), INP (সাড়া, ≤ ২০০ ms), CLS (স্থিরতা, ≤ ০.১); রায় field-এর p75-এ।
  2. Lab আর field: Lighthouse আর Playwright তুলনা ও gate-এর জন্য; RUM বা CrUX রায়ের জন্য। Lab-এ INP নেই, তার জায়গায় TBT.
  3. সত্যিকারের regression: একটি ৪.৭ MB ব্যানারে মোবাইল LCP ০.৮ থেকে ২৫.১ s; TBT আর CLS শূন্যই থাকল, তাই কোন মাপ কোন সময় দেখে, জানুন।
  4. Budget-ই পাহারাদার: LHCI-তে ৩ run, median, absolute সীমা; সাথে baseline-এর tolerance. ঠিক build exit 0, ব্যানার build exit 1.
  5. মাপার যন্ত্র যাচাই করুন: পাতার ভেতরে mark আর observer দিয়ে মাপুন; expect-এর polling ৪৩০ ms-কে ৮৭০ দেখিয়েছিল।

পরের পর্বে: Tester-এর চোখে নিরাপত্তা — OWASP Top 10-এর ঝুঁকিগুলো থেকে বাজারঘরের জন্য test case বানানো, আর কোন কাজ শুধু অনুমতি পাওয়া নিজের system-এ।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান