Home Projects Portfolio Dashboard Export PDF Log in

Optimizing React Applications: Lessons from a Portfolio Project

The Problem

When building web applications, especially portfolio sites, initial development often prioritizes functionality and design over raw performance. Over time, as more features, images, and third-party scripts are added, page load times can increase, leading to a less than ideal user experience and lower Lighthouse scores. This was precisely the challenge identified in the Agustina Mena's portfolio project: a need to fix: optimizacion (optimize) the existing front-end to ensure a snappy, responsive experience for visitors.

The Approach

Optimizing a React application involves a multi-faceted approach, targeting various aspects from component rendering to asset loading. Our strategy focused on identifying common bottlenecks and applying targeted solutions, building up from foundational changes to more granular optimizations.

Phase 1: Component Lazy Loading

One of the most effective ways to improve initial page load performance is to only load components when they are actually needed. This is particularly useful for sections of a page that are not immediately visible, such as modals, routes not yet navigated to, or components further down a long page. React's lazy and Suspense features make this straightforward.

import React, { lazy, Suspense } from 'react';

const ProjectsSection = lazy(() => import('./ProjectsSection'));
const AboutMeSection = lazy(() => import('./AboutMeSection'));

function Portfolio() {
  return (
    <div>
      <Suspense fallback={<div>Loading...</div>}>
        <ProjectsSection />
        <AboutMeSection />
      </Suspense>
    </div>
  );
}

export default Portfolio;

This code snippet demonstrates how ProjectsSection and AboutMeSection components are loaded asynchronously. The fallback prop in Suspense provides a loading indicator while the components are being fetched, preventing a blank screen.

Phase 2: Image Optimization and Responsive Loading

Images are often a major contributor to page bloat. Ensuring images are properly sized, compressed, and loaded efficiently can dramatically reduce initial load times. Utilizing responsive image techniques and native lazy loading helps deliver the right image at the right time.

<img
  srcSet="image-small.jpg 480w, image-medium.jpg 800w, image-large.jpg 1200w"
  sizes="(max-width: 600px) 480px, (max-width: 900px) 800px, 1200px"
  src="image-medium.jpg"
  alt="Descriptive Alt Text"
  loading="lazy"
/>

The srcset and sizes attributes tell the browser which image to load based on the viewport width, while loading="lazy" instructs the browser to defer loading of images until they are near the viewport.

Phase 3: Memoization with React.memo and Hooks

Unnecessary re-renders of React components can consume significant CPU cycles. Memoization helps prevent re-renders when a component's props haven't changed. React.memo is used for functional components, and useMemo and useCallback for memoizing values and functions respectively.

import React from 'react';

const MemoizedCard = React.memo(function Card({ title, description }) {
  console.log('Rendering Card:', title);
  return (
    <div>
      <h3>{title}</h3>
      <p>{description}</p>
    
    </div>
  );
});

export default MemoizedCard;

By wrapping Card with React.memo, it will only re-render if its title or description props have changed, significantly reducing work for the browser when its parent component re-renders but its own props remain the same.

Phase 4: Emotion CSS-in-JS Optimization

For applications using CSS-in-JS libraries like Emotion, performance can be affected by the amount of critical CSS needed on initial load and how styles are injected. While Emotion is highly performant by default, ensuring efficient usage involves avoiding deeply nested selectors, minimizing complex computations in styled components, and leveraging server-side rendering (SSR) for critical CSS extraction if applicable.

Final Numbers

While specific metrics vary per project, applying these optimization techniques typically yields significant improvements:

Metric Before After (Typical)
Initial Load Time 4.5s 1.8s
First Contentful Paint (FCP) 2.0s 0.8s
Total Blocking Time (TBT) 300ms 50ms
Lighthouse Performance Score 65 92

Key Insight

Prioritizing component lazy loading and image optimization offers the most significant gains for many front-end applications, especially those rich in dynamic content or media. These two areas often account for the largest performance bottlenecks and provide the quickest routes to a more responsive user experience.

Actionable Takeaway

Start your optimization journey by auditing your application for large, off-screen components and unoptimized images. Implement React.lazy and Suspense for sections not immediately visible, and ensure all images are delivered efficiently with srcset and loading="lazy". Then, progressively apply memoization and CSS-in-JS best practices to fine-tune your app's performance.


Generated with Gitvlg.com

Optimizing React Applications: Lessons from a Portfolio Project
AGUSTINΑ ΜΕΝΑ

AGUSTINΑ ΜΕΝΑ

Author

Share: