Introduction

Overview of the Importance of Performance Assessment in Web Development

In today’s fast-paced digital landscape, web performance is a critical factor that directly impacts user experience, engagement, and ultimately, business success. Studies have shown that even a one-second delay in page load time can lead to a significant drop in conversions and user satisfaction. As users become more accustomed to high-speed internet and instant access to information, their tolerance for slow-loading websites diminishes.

Performance assessment in web development involves measuring, analyzing, and optimizing various aspects of a website to ensure it loads quickly, runs smoothly, and provides a seamless user experience. This process not only improves the immediate user experience but also contributes to long-term benefits such as better SEO rankings, increased user retention, and higher conversion rates.

Key reasons why performance assessment is crucial in web development include:

  1. Enhanced User Experience: Fast-loading websites provide a better user experience, reducing bounce rates and encouraging users to stay longer and engage more with the content.

  2. SEO Benefits: Search engines like Google prioritize fast-loading websites, which can lead to higher search rankings and more organic traffic.

  3. Higher Conversion Rates: Speed is directly linked to conversion rates. A faster website can lead to more sign-ups, purchases, and other desired user actions.

  4. Reduced Operational Costs: Optimizing performance can lead to more efficient use of server resources, reducing hosting and bandwidth costs.

  5. Competitive Advantage: In a competitive market, a fast and responsive website can set you apart from competitors who may have slower websites.

Brief Introduction to the Tools and Methodologies Covered in the Article

This article delves into various tools and methodologies that web developers can use to assess and optimize web performance. By understanding and implementing these tools, developers can gain valuable insights into how their websites perform and identify areas for improvement. The key areas we will cover include:

  1. Google Lighthouse Audits: Google Lighthouse is an open-source tool that provides a comprehensive performance audit of web pages. It measures various performance metrics and offers actionable recommendations to improve page speed and overall performance.

  2. Custom Performance Metrics and Monitoring: While standard performance metrics are crucial, custom metrics tailored to specific user experiences or business goals can provide deeper insights. We will explore how to set up and monitor these custom metrics.

  3. Competitor Performance Benchmarking: Understanding how your website performs compared to competitors is essential for identifying strengths and weaknesses. We will discuss tools and techniques for benchmarking your website’s performance against industry leaders.

Importance of Continuous Monitoring and Improvement in Web Performance

Performance optimization is not a one-time task but an ongoing process. Continuous monitoring and improvement are essential to maintaining high performance and adapting to changes in technology, user behavior, and market trends. Here are some reasons why continuous monitoring is crucial:

  1. Adapting to Changes: Web technologies and user expectations are constantly evolving. Regular performance assessments help ensure your website keeps up with these changes.

  2. Identifying New Issues: Performance issues can arise at any time due to code changes, third-party integrations, or increased traffic. Continuous monitoring helps identify and address these issues promptly.

  3. Tracking Improvements: Ongoing performance assessments allow you to track the effectiveness of optimization efforts and make data-driven decisions for further improvements.

  4. Maintaining Competitive Edge: Regularly benchmarking and optimizing performance ensures that your website remains competitive in terms of speed and user experience.

By leveraging tools like Google Lighthouse, setting up custom performance metrics, and benchmarking against competitors, developers can create a robust strategy for continuous performance improvement. This approach not only enhances the immediate user experience but also positions the website for long-term success in a competitive digital landscape.

In the following sections, we will dive deep into each of these tools and methodologies, providing detailed explanations, practical examples, and actionable tips to help you optimize your web performance effectively.

Google Lighthouse Audits

1. Introduction to Google Lighthouse

Overview of Google Lighthouse

Google Lighthouse is an open-source, automated tool designed to help developers improve the quality of their web pages. Lighthouse provides a comprehensive audit of web pages and offers insights into several key areas including performance, accessibility, SEO, and more. It is an essential tool for developers aiming to optimize their websites and enhance user experience.

Key Features and Benefits

  1. Performance Analysis: Lighthouse measures critical performance metrics such as page load times, interactivity, and visual stability.

  2. Accessibility Checks: It evaluates how accessible a web page is to users with disabilities, providing actionable recommendations for improvements.

  3. SEO Insights: Lighthouse audits SEO best practices to ensure that web pages are optimized for search engines.

  4. Progressive Web App (PWA) Validation: It checks if a web app meets PWA standards, ensuring a reliable and engaging user experience.

  5. Best Practices: Lighthouse audits adherence to web development best practices, including security and resource optimization.

How Lighthouse Fits into the Web Performance Ecosystem

Lighthouse is a crucial component of the web performance ecosystem, serving as both a diagnostic tool and a guide for optimization. It integrates seamlessly with other performance tools like Google PageSpeed Insights, providing a holistic view of a website’s performance. By incorporating Lighthouse audits into the development workflow, developers can ensure continuous performance improvements and maintain high standards for web quality.

2. Setting Up and Running Audits

Installing and Setting Up Google Lighthouse

Lighthouse can be used in several ways, each offering flexibility depending on the developer’s workflow:

  1. Chrome DevTools: Lighthouse is built into the Chrome DevTools, making it accessible directly from the browser.

  2. Lighthouse CLI: For more advanced use cases, Lighthouse can be run via the command line interface (CLI).

  3. Lighthouse CI: Continuous integration with Lighthouse CI allows automated performance checks as part of the build process.

Running Audits via Chrome DevTools, Lighthouse CLI, and Lighthouse CI

Chrome DevTools

  1. Open Chrome DevTools (F12 or right-click > Inspect).

  2. Navigate to the “Lighthouse” tab.

  3. Select the desired categories (Performance, Accessibility, Best Practices, SEO, PWA).

  4. Click “Generate report” to run the audit.

Lighthouse CLI

  1. Install Lighthouse CLI globally using npm:

    npm install -g lighthouse

  2. Run Lighthouse on a URL:

    lighthouse https://example.com --output html --output-path ./report.html
Lighthouse CI

  1. Install Lighthouse CI:

    npm install -g @lhci/cli

  2. Initialize Lighthouse CI:

    lhci wizard

  3. Run Lighthouse CI:

    lhci autorun

Understanding the Lighthouse Report

The Lighthouse report provides a detailed analysis of various metrics and audits. Each section of the report is color-coded to indicate performance levels (red for poor, yellow for needs improvement, green for good). Key sections include:

  1. Performance: Metrics like FCP, LCP, and TTI.

  2. Accessibility: Checks for color contrast, ARIA roles, and more.

  3. Best Practices: Security checks, HTTPS, and JavaScript practices.

  4. SEO: Metadata, crawlability, and structured data.

  5. PWA: Criteria for Progressive Web Apps.

3. Performance Metrics Analyzed by Lighthouse

Detailed Explanation of Metrics

  1. FCP (First Contentful Paint): Measures the time it takes for the first piece of content to be rendered on the screen. A faster FCP improves user perception of performance.

  2. LCP (Largest Contentful Paint): The time it takes for the largest content element to be visible within the viewport. This metric reflects the loading performance of the main content.

  3. FID (First Input Delay): Measures the time from when a user first interacts with the page to when the browser responds to that interaction. It indicates the responsiveness of a page.

  4. CLS (Cumulative Layout Shift): Quantifies the amount of unexpected layout shift during the page’s lifecycle. Lower CLS values indicate better visual stability.

  5. TTI (Time to Interactive): The time it takes for the page to become fully interactive, meaning it can reliably respond to user input.

How These Metrics Impact User Experience and SEO

  • FCP and LCP: Faster paint times lead to a better first impression and perceived performance, which can reduce bounce rates.

  • FID: Low input delay ensures a smooth user experience, especially important for interactive elements.

  • CLS: Stable layouts prevent users from misclicking or experiencing visual jarring.

  • TTI: Ensures that users can interact with the page as soon as possible, enhancing usability and satisfaction.

4. Improving Performance Based on Lighthouse Recommendations

Common Performance Issues Identified by Lighthouse

  1. Render-Blocking Resources: Scripts and stylesheets that delay the rendering of content.

  2. Unoptimized Images: Large, uncompressed images that slow down load times.

  3. Inefficient JavaScript: Heavy or poorly written JavaScript that affects performance.

  4. Excessive DOM Size: Large or complex Document Object Model (DOM) structures that impact rendering performance.

Practical Steps and Code Snippets to Address These Issues

Render-Blocking Resources

  1. Defer or async JavaScript loading:

    <script src="script.js" defer></script>

  2. Inline critical CSS and load non-critical CSS asynchronously:

    <link
  rel="stylesheet"
  href="styles.css"
  media="print"
  onload="this.media='all'"
/>
Unoptimized Images

  1. Use modern image formats like WebP:

    <img src="image.webp" alt="Description" />

  2. Lazy load images:

    <img src="image.jpg" alt="Description" loading="lazy" />
Inefficient JavaScript

  1. Minify and bundle JavaScript files using tools like Webpack:

    npm install --save-dev webpack webpack-cli

  2. Remove unused JavaScript (tree-shaking).

Excessive DOM Size

  1. Simplify DOM structure by reducing nested elements.

  2. Use efficient frameworks and libraries that manage the DOM effectively.

Case Studies of Performance Improvements Using Lighthouse Recommendations

  1. E-commerce Site:

    • Initial audit revealed large render-blocking resources and unoptimized images.

    • By deferring JavaScript and using WebP images, the site improved its FCP by 40% and LCP by 35%.

  2. News Website:

    • Lighthouse audit indicated high CLS due to dynamically loaded ads.

    • Implementing fixed-size containers for ads reduced CLS by 60%.

  3. Blog Platform:

    • Audit showed heavy JavaScript impacting TTI.

    • Code splitting and lazy loading reduced TTI by 50%.

By addressing these common issues and implementing the recommended changes, websites can significantly enhance their performance, leading to better user experiences and higher SEO rankings. Google Lighthouse serves as an invaluable tool in this process, providing clear guidance and actionable insights.

Custom Performance Metrics and Monitoring

1. Introduction to Custom Performance Metrics

Why Custom Metrics are Important

Custom performance metrics provide a tailored view of how well your website meets specific user experiences and business goals. While standard metrics like FCP, LCP, and TTI are crucial for understanding general performance, custom metrics allow you to focus on what matters most for your users and business. These metrics can measure unique interactions, user flows, and business-critical events that are not covered by default performance tools.

Custom metrics help in:

  • Understanding User Behavior: Track specific actions and interactions that are important for your users.

  • Optimizing Key Performance Areas: Focus on areas that directly impact business goals, such as conversion rates or user engagement.

  • Providing Specific Insights: Gain detailed insights into specific parts of your website, allowing for targeted optimizations.

Examples of Custom Metrics

  1. Time to First Interaction (TTFI): Measures the time taken for a user to make the first meaningful interaction on the page.

  2. Time to Complete Checkout: In e-commerce sites, tracks the time from adding an item to the cart to completing the purchase.

  3. Form Submission Time: Measures the time taken to fill and submit a form.

  4. Content Engagement Time: Tracks the time users spend engaging with specific content, such as videos or articles.

2. Setting Up Custom Metrics

Using the PerformanceObserver API to Track Custom Metrics

The PerformanceObserver API allows you to observe and collect performance entries as they occur. This API is useful for tracking custom performance metrics in real-time.

// Example of using PerformanceObserver to track custom metrics
const observer = new PerformanceObserver((list) => {
  const entries = list.getEntries();
  entries.forEach((entry) => {
    console.log(`Name: ${entry.name}, Duration: ${entry.duration}`);
  });
});

// Start observing
observer.observe({ entryTypes: ["measure"] });

// Measure custom events
performance.mark("start-custom-metric");
// Simulate some operation
setTimeout(() => {
  performance.mark("end-custom-metric");
  performance.measure(
    "Custom Metric",
    "start-custom-metric",
    "end-custom-metric"
  );
}, 1000);

Implementing Custom JavaScript to Measure User Interactions and Timings

You can create custom JavaScript functions to measure specific user interactions and timings. This involves using the performance.now() method to capture high-resolution timestamps.

// Track time to first interaction
let firstInteraction = false;

function trackFirstInteraction() {
  if (!firstInteraction) {
    firstInteraction = true;
    const ttfInteraction = performance.now();
    console.log(`Time to First Interaction: ${ttfInteraction} ms`);
    // Send this metric to your analytics server
  }
}

document.addEventListener("click", trackFirstInteraction);
document.addEventListener("keydown", trackFirstInteraction);

Code Snippets and Examples

  1. Custom Metric for Content Engagement Time:
// Track engagement time for a specific content section
let engagementStart;
const contentSection = document.getElementById("content-section");

contentSection.addEventListener("mouseenter", () => {
  engagementStart = performance.now();
});

contentSection.addEventListener("mouseleave", () => {
  if (engagementStart) {
    const engagementTime = performance.now() - engagementStart;
    console.log(`Content Engagement Time: ${engagementTime} ms`);
    // Send this metric to your analytics server
  }
});
  1. Custom Metric for Form Submission Time:
// Track time to complete form submission
const form = document.getElementById("form");
let formStartTime;

form.addEventListener(
  "focusin",
  () => {
    formStartTime = performance.now();
  },
  { once: true }
);

form.addEventListener("submit", (event) => {
  event.preventDefault();
  const formEndTime = performance.now();
  const formSubmissionTime = formEndTime - formStartTime;
  console.log(`Form Submission Time: ${formSubmissionTime} ms`);
  // Send this metric to your analytics server
});

3. Monitoring and Reporting Custom Metrics

Integrating Custom Metrics with Performance Monitoring Tools

To gain continuous insights and monitor custom performance metrics, you can integrate them with performance monitoring tools like Google Analytics, New Relic, and DataDog.

Google Analytics

You can use Google Analytics’ gtag to send custom events:

// Send custom metric to Google Analytics
function sendCustomMetric(name, value) {
  gtag("event", "timing_complete", {
    name: name,
    value: value,
    event_category: "Custom Metrics",
  });
}

// Example usage
sendCustomMetric("Content Engagement Time", engagementTime);
New Relic

New Relic allows you to send custom events and metrics using its JavaScript API:

// Send custom metric to New Relic
newrelic.addPageAction("customMetric", {
  name: "Content Engagement Time",
  value: engagementTime,
});
DataDog

With DataDog, you can use the datadogRum API to track custom user actions:

// Initialize DataDog RUM
datadogRum.init({
  applicationId: "YOUR_APPLICATION_ID",
  clientToken: "YOUR_CLIENT_TOKEN",
  site: "datadoghq.com",
  service: "my-web-app",
  env: "prod",
  version: "1.0.0",
  sampleRate: 100,
  trackInteractions: true,
});

// Send custom metric to DataDog
datadogRum.addUserAction("customMetric", {
  name: "Content Engagement Time",
  value: engagementTime,
});

Setting Up Dashboards and Alerts for Real-Time Performance Monitoring

To ensure continuous monitoring, set up dashboards and alerts:

  1. Google Analytics: Create custom reports and dashboards to track performance metrics.

  2. New Relic: Use New Relic One to create custom dashboards and alerts based on custom metrics.

  3. DataDog: Set up custom dashboards and configure alerts for specific thresholds.

Case Studies of Custom Metrics Implementation and Their Impact on Performance Optimization

Case Study 1: E-commerce Site

  • Objective: Reduce the time to complete checkout.

  • Custom Metric: Time to Complete Checkout.

  • Implementation: Tracked the time taken from adding items to the cart to completing the purchase.

  • Result: Identified bottlenecks in the checkout process and optimized them, reducing checkout time by 30%.

Case Study 2: News Platform

  • Objective: Improve content engagement.

  • Custom Metric: Content Engagement Time.

  • Implementation: Measured the time users spent engaging with articles and videos.

  • Result: Enhanced content layout and interactivity, increasing engagement time by 20%.

Case Study 3: SaaS Application

  • Objective: Optimize form submission process.

  • Custom Metric: Form Submission Time.

  • Implementation: Tracked the time taken to fill and submit critical forms.

  • Result: Simplified forms and reduced submission time by 25%.

By implementing and monitoring custom performance metrics, you can gain deeper insights into user behavior and make data-driven decisions to enhance the performance and user experience of your web applications.

Competitor Performance Benchmarking

1. Introduction to Competitor Benchmarking

Why Benchmarking Against Competitors is Important

Benchmarking your website’s performance against competitors is crucial for several reasons:

  1. Understanding Industry Standards: It helps you understand the performance standards in your industry, providing a baseline to measure your own site against.

  2. Identifying Weaknesses: Highlight areas where your website lags behind competitors, guiding where to focus your optimization efforts.

  3. Gaining Competitive Advantage: By continuously improving your site’s performance, you can gain a competitive edge in terms of user experience and SEO.

  4. Informed Decision Making: Provides data-driven insights for making strategic decisions on web performance improvements.

How to Identify Key Competitors for Benchmarking

Identifying the right competitors is essential for effective benchmarking. Consider the following steps:

  1. Direct Competitors: Identify businesses offering similar products or services.

  2. Industry Leaders: Benchmark against industry leaders to understand the highest standards of performance.

  3. SEO Competitors: Use tools like Ahrefs or SEMrush to find competitors ranking for the same keywords.

2. Tools for Competitor Benchmarking

Overview of Tools

Several tools can help you gather and analyze competitor performance data:

  1. WebPageTest: Offers detailed performance analysis and allows you to compare multiple URLs.

  2. Pingdom: Provides performance monitoring and benchmarking features.

  3. GTmetrix: Combines data from Google Lighthouse and WebPageTest to provide comprehensive performance insights.

How to Use These Tools to Gather Competitor Performance Data

WebPageTest

  1. Set Up a Test:

    • Go to WebPageTest.

    • Enter the URL of the competitor’s website.

    • Select test location and browser.

    • Click “Start Test.”

  2. Analyze Results:

    • View metrics such as Load Time, Time to First Byte (TTFB), Start Render, and Speed Index.

    • Use the “Comparison” feature to compare multiple competitors.

Pingdom

  1. Set Up a Test:

    • Go to Pingdom Tools.

    • Enter the URL of the competitor’s website.

    • Select test location.

    • Click “Start Test.”

  2. Analyze Results:

    • Review metrics like Performance Grade, Page Size, and Load Time.

    • Use historical data to track performance changes over time.

GTmetrix

  1. Set Up a Test:

    • Go to GTmetrix.

    • Enter the URL of the competitor’s website.

    • Select test options (location, browser, connection speed).

    • Click “Analyze.”

  2. Analyze Results:

    • Review metrics such as Performance Scores, Page Load Details, and Recommendations.

    • Use the “Compare” feature to benchmark against multiple competitors.

3. Analyzing and Interpreting Benchmark Data

Key Metrics to Compare with Competitors

Focus on the following key metrics when comparing your site with competitors:

  1. Page Load Time: Total time to fully load the page.

  2. Time to First Byte (TTFB): Time taken for the server to respond.

  3. First Contentful Paint (FCP): Time taken to render the first piece of content.

  4. Largest Contentful Paint (LCP): Time taken to render the largest piece of content.

  5. Cumulative Layout Shift (CLS): Measures visual stability during page load.

  6. Total Blocking Time (TBT): Time the main thread was blocked, impacting interactivity.

How to Interpret Benchmarking Data to Identify Areas of Improvement

  1. Compare Key Metrics:

    • Identify where your site underperforms compared to competitors.

    • Focus on metrics that directly impact user experience and SEO.

  2. Identify Bottlenecks:

    • Analyze detailed reports to pinpoint specific bottlenecks (e.g., slow server response, large images, render-blocking resources).

  3. Prioritize Issues:

    • Prioritize performance issues based on their impact on user experience and ease of implementation.

Visualizing Benchmarking Data for Better Understanding

Use visualization tools like Google Data Studio or Tableau to create dashboards and reports:

  1. Create Dashboards:

    • Combine data from multiple tools into a single dashboard.

    • Use graphs and charts to visualize key metrics.

  2. Highlight Key Insights:

    • Use annotations to highlight areas where competitors outperform your site.

    • Display historical data to show performance trends over time.

4. Implementing Improvements Based on Benchmarking

Practical Steps to Close the Performance Gap with Competitors

  1. Optimize Server Response Time:

    • Use a Content Delivery Network (CDN) to reduce TTFB.

    • Optimize server configuration and database queries.

  2. Improve Resource Loading:

    • Minify CSS, JavaScript, and HTML files.

    • Implement lazy loading for images and videos.

  3. Enhance Render Performance:

    • Eliminate render-blocking resources.

    • Use efficient CSS and JavaScript to improve FCP and LCP.

Prioritizing Improvements Based on Impact and Feasibility

  1. Impact Assessment:

    • Focus on improvements that have the most significant impact on key metrics.

    • Use data from benchmarking tools to identify high-impact areas.

  2. Feasibility Analysis:

    • Evaluate the technical complexity and resources required for each improvement.

    • Prioritize low-effort, high-impact changes for quick wins.

Case Studies of Successful Performance Improvements Based on Benchmarking Insights

Case Study 1: E-commerce Site

  • Objective: Reduce page load time.

  • Benchmark Insight: Competitors had faster TTFB and optimized image loading.

  • Implementation: Used a CDN, compressed images, and implemented lazy loading.

  • Result: Reduced page load time by 40%, leading to a 15% increase in conversion rates.

Case Study 2: News Platform

  • Objective: Improve FCP and LCP.

  • Benchmark Insight: Competitors had optimized CSS and eliminated render-blocking resources.

  • Implementation: Minified CSS, deferred non-critical JavaScript, and used asynchronous loading for third-party scripts.

  • Result: Improved FCP by 30% and LCP by 25%, increasing user engagement.

Case Study 3: SaaS Application

  • Objective: Enhance interactivity and reduce TBT.

  • Benchmark Insight: Competitors had better optimized JavaScript and used modern frameworks.

  • Implementation: Refactored JavaScript, implemented code splitting, and used Web Workers.

  • Result: Reduced TBT by 35%, leading to a smoother user experience and higher user retention.

By benchmarking against competitors, you can identify performance gaps, prioritize improvements, and implement targeted optimizations to enhance your website’s performance, user experience, and SEO rankings.

Conclusion

Recap of the Importance of Using Tools to Assess and Improve Web Performance

In today’s fast-paced digital world, web performance is crucial for user experience, SEO, and overall business success. Using performance assessment tools is essential to:

  1. Identify Bottlenecks: Tools like Google Lighthouse, WebPageTest, and others help pinpoint specific areas that need improvement, such as slow server response times, unoptimized images, and render-blocking resources.

  2. Measure and Monitor Performance: These tools provide detailed metrics and continuous monitoring capabilities, allowing you to track performance over time and ensure that improvements are sustained.

  3. Benchmark Against Competitors: Competitor benchmarking tools provide insights into how your website stacks up against others in your industry, helping you stay competitive and set realistic performance goals.

  4. Implement Effective Optimizations: The data gathered from these tools guide you in implementing targeted optimizations that have the most significant impact on performance, user experience, and SEO.

Encouragement to Regularly Use Lighthouse, Custom Metrics, and Competitor Benchmarking for Continuous Performance Improvement

To maintain and improve web performance, it’s essential to adopt a proactive and continuous approach:

  1. Regular Audits with Google Lighthouse: Conduct regular audits using Google Lighthouse to keep track of your website’s performance, accessibility, best practices, SEO, and PWA capabilities. This will help you stay on top of any issues that might arise and address them promptly.

  2. Track Custom Performance Metrics: Implement and monitor custom metrics tailored to your specific user experiences and business goals. Use tools like the PerformanceObserver API, Google Analytics, New Relic, and DataDog to track these metrics and gain deeper insights into user interactions and behaviors.

  3. Competitor Benchmarking: Regularly benchmark your website against key competitors to identify performance gaps and prioritize improvements. Use tools like WebPageTest, Pingdom, and GTmetrix to gather comprehensive performance data and set realistic performance targets.

  4. Continuous Improvement: Performance optimization is not a one-time task but an ongoing process. Regularly review your site’s performance, implement best practices, and stay updated with the latest trends and techniques in web performance optimization.

Teaser for the Next Article in the Series

Stay tuned for the next article in our series, where we will dive deeper into advanced performance optimization techniques and tools. We’ll explore topics such as:

  1. Advanced Caching Strategies: Learn how to implement advanced caching techniques to reduce server load and improve load times.

  2. Progressive Web Apps (PWAs): Understand how PWAs can enhance performance, reliability, and user engagement.

  3. Server-Side Rendering (SSR) and Static Site Generation (SSG): Discover the benefits of SSR and SSG for performance and SEO, and how to implement them in your projects.

  4. Optimizing Third-Party Scripts: Strategies to manage and optimize third-party scripts to minimize their impact on performance.

By implementing these advanced techniques, you’ll be well-equipped to take your web performance to the next level, ensuring a fast, reliable, and engaging experience for your users.

Stay tuned for more insights and practical tips in our upcoming article!

Hi there, I’m Darshan Jitendra Chobarkar, a freelance web developer who’s managed to survive the caffeine-fueled world of coding from the comfort of Pune. If you found the article you just read intriguing (or even if you’re just here to silently judge my coding style), why not dive deeper into my digital world? Check out my portfolio at https://darshanwebdev.com/ – it’s where I showcase my projects, minus the late-night bug fixing drama.

For a more ‘professional’ glimpse of me (yes, I clean up nice in a LinkedIn profile), connect with me at https://www.linkedin.com/in/dchobarkar/. Or if you’re brave enough to see where the coding magic happens (spoiler: lots of Googling), my GitHub is your destination at https://github.com/dchobarkar. And, for those who’ve enjoyed my take on this blog article, there’s more where that came from at https://dchobarkar.github.io/. Dive in, leave a comment, or just enjoy the ride – looking forward to hearing from you!

<
Previous Post
Web Boost - 11: Mobile Performance Optimization
>
Next Post
Web Boost - 13: Implementing Code Splitting