Forem: Rumen Dimov

How I Performance Optimised My Next.js App

Rumen Dimov — Sat, 25 Oct 2025 21:52:00 +0000

So I recently went down a bit of a rabbit hole optimising my Next.js app, and honestly? It was crazy. I wanted to share what I learned because there were some surprises along the way, and maybe it will help someone else trying to speed up their site or it will stir up a nice discussion. Either way, it's a win-win situation for me 😊.

Disclaimer - the things I learned are both from research (google, stackoverflow, dev.to, shady techy websites) and, of course, AI. The cover image is AI generated using Gemini.

The Big Plot Twist

Here's the thing that almost made me lose my mind: my local production build was scoring like 75/100 on Lighthouse. I was freaking out trying everything, questioning my very own existence...🥴 and then I deployed it to actual production and...it hit 98/100. How about that?!

Turns out local builds can be super misleading. Your local machine, the way Next.js serves files locally, network conditions – it is all very different from real production. I don't really know the ins and outs of it but the local build is not accurate. So if you're testing locally and getting discouraged, just deploy it and see what happens. You might be pleasantly surprised.

My Approach (aka "Does It Feel Fast? 😂")

Look I'm not going to pretend I know if everything I did follows some official "best practices" handbook. A lot of what I did was based on perceived performance – does it feel fast when I use it and does it make sense? Do things load smoothly? Is there annoying layout shift? Also, this is an experiment and a hobby project, so some of the things I did were can be rightfully seen as an exeggeration, i.e. feel free to judge me 😊.
That said, I threw a bunch of optimisations at this thing, and collectively they worked. Here's what I did:

Images Were Eating My Performance

First thing I attacked was images. Next.js has great image optimisation built in, but you gotta configure it properly.

I set up AVIF and WebP formats (way smaller than JPEGs), and added device-specific sizing. Then I went aggressive on caching – 1 year cache headers on images. Why? Because once someone downloads an image, there's no reason to download it again.
The file size difference is real – I was seeing 30-50% smaller images with modern formats.
Again, reminder, I am not teaching, I am just sharing what I did so if someone knows better, please feel free to level some serious criticism, I'm happy to learn.

Fonts Can Block Your Entire Page

This one was really strange to me at first. I used to just throw Google Fonts in there and call it a day. But fonts can actually block your page from rendering while they load. Next.js has a solution:

The display: 'swap' is key – it shows a fallback font immediately while your web font loads in the background. No more blank screens waiting for fonts.

Cache Everything That Doesn't Change

I went a bit crazy with caching:

Static assets: 1 year
Fonts: 1 year
Optimised images: 1 year

Why so aggressive? Because these files don't change. When I deploy a new version, Next.js generates new filenames anyway, so there's no risk of serving stale content. Feel free to disagree.

Code Splitting Saved My Bundle Size

This was solid. I had some heavy components – charts, modals, stuff like that. They were bloating my initial JavaScript bundle. So I dynamically imported them:

The ssr: false means it only loads on the client, and only when needed. This cut my initial bundle size by...I don't know how much but it was definitely by a lot.

Tree-Shaking Icons

Icon libraries are sneaky bundle size killers. I was using lucide-react and @radix-ui/react-icons, which have like hundreds of icons. I was only using maybe 15.

Database Queries

On the backend I made sure to only fetch the columns I actually needed, which makes perfect sense. I also used joins instead of multiple queries when I needed related data. Fewer round trips to the database = faster API responses.

Skeleton Loaders Are Your Friend 😂

Layout shift is annoying. You know when you're reading something and suddenly the whole page jumps because an image loaded? Not a great UX is it.
I added skeleton loaders for basically everything that loads asynchronously. I have 7 different loading.tsx files for different sections:

This keeps the layout stable while content loads.

Server Components vs Client Components

Next.js 13+ has Server Components thing and I think it's great for performance. The basic rule I follow:

Server Components (default): Marketing pages, content that doesn't need interactivity, and of course anything that renders a lot of data
Client Components: Forms, interactive widgets, anything that needs useState or onClick and that does not require a whole lotta data.

Here's why I think the Server Components are so good for data-heavy stuff: they render on the server, so all that data processing happens server-side. The client just gets the final HTML. No huge JSON payloads sent over the network, no client-side rendering loops.

For example, I have an analytics dashboard that displays tons of data, charts, metrics – all that gets rendered on the server. The browser just receives ready-to-display HTML. Compare that to a traditional SPA where you'd fetch all that data, parse it client-side, then render it. Way more work for the browser.

Server Components mean less JavaScript shipped to the browser. Less JavaScript = faster page.

What do you think?

The Little Things That Add Up:

Middleware efficiency – I excluded static assets from auth checks. No point checking authentication on every single image request...or is there?
useMemo for expensive calculations – Had a filtering function that ran on every render so wrapped in useMemo

Some Honest Thoughts

Did I need to do all this? Maybe not. How cyber safe is it? It certainly has flaws. Could some of these optimisations be overkill? Possibly. But the end result is a site that feels fast and I experimented the hell out of this thing...😂 most importantly I had fun.
I'm sure there are more optimisations I have missed and this is where you come in. Also at some point you gotta ship the thing and move on to actually building features and enjoy life.

Also, seriously, don't stress too much about your local Lighthouse scores. They can be insanely misleading. Test in production (or a production-like environment) to get real numbers.

My Stack
For context, I'm using:

Next.js 14 with App Router
TypeScript
Tailwind CSS
Supabase (PostgreSQL)
Deployed on Vercel

Hope someone find some value in this!

Happy coding!!! 😊

Areas in ASP.NET Core: The Architectural Feature You're Probably Missing

Rumen Dimov — Mon, 04 Aug 2025 21:52:19 +0000

Introduction

If you've been working with ASP.NET Core and haven't encountered Areas yet, you're not alone. Despite being a powerful organisational feature, Areas are often overlooked in tutorials and beginner resources. This oversight leads many developers to create convoluted controller hierarchies and strange architectural patterns that Areas were specifically designed to solve.

I've seen projects where developers create "super controllers" or awkward folder structures trying to achieve what Areas provide out of the box. Let's fix that.

What Are Areas?

Areas are a feature in ASP.NET Core that allow you to partition your web application into smaller functional groups. Each area represents a distinct section of your application with its own set of controllers, views, and models. Think of them as mini-MVC applications within your main application.

Why Areas Matter

1. Logical Organisation

Without Areas, large applications often end up with dozens of controllers in a single folder, making navigation and maintenance a nightmare. Areas let you group related functionality together.

2. Team Collaboration

Different teams can work on different areas without stepping on each other's toes. The Admin team works in the Admin area, the API team in the API area, and so on.

3. Namespace Separation

Areas provide automatic namespace separation, preventing naming conflicts and making your code more maintainable.

4. Route Management

Areas provide built-in route segregation, making your URL structure cleaner and more intuitive.

Real-World Example: E-Commerce Application

Let's say you're building an e-commerce platform. Without Areas, you might have:

Controllers/
├── HomeController.cs
├── ProductController.cs
├── CategoryController.cs
├── AdminProductController.cs
├── AdminCategoryController.cs
├── AdminUserController.cs
├── AdminDashboardController.cs
├── CustomerOrderController.cs
├── CustomerProfileController.cs
└── ... (dozens more)

This quickly becomes unmanageable. With Areas, you get:

Areas/
├── Admin/
│   ├── Controllers/
│   │   ├── ProductController.cs
│   │   ├── CategoryController.cs
│   │   ├── UserController.cs
│   │   └── DashboardController.cs
│   ├── Views/
│   └── Models/
├── Customer/
│   ├── Controllers/
│   │   ├── OrderController.cs
│   │   └── ProfileController.cs
│   ├── Views/
│   └── Models/
└── Public/
    ├── Controllers/
    │   ├── HomeController.cs
    │   ├── ProductController.cs
    │   └── CategoryController.cs
    ├── Views/
    └── Models/

Implementing Areas

Step 1: Create an Area
// Create folder structure:
// Areas/Admin/Controllers/
// Areas/Admin/Views/
// Areas/Admin/Models/

Step 2: Configure the Controller

namespace YourApp.Areas.Admin.Controllers
{
    [Area("Admin")]
    [Route("Admin/[controller]/[action]")]
    public class DashboardController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }
    }
}

Step 3: Update Startup Configuration

app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "areas",
            pattern: "{area:exists}/{controller=Home}/{action=Index}/{id?}");

        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });

Common Pitfalls and Solutions

The "God Controller" Anti-Pattern

Without Areas, developers often create controllers like AdminController with dozens of actions for all administrative functions. This violates the Single Responsibility Principle and makes testing difficult.
Solution: Use an Admin area with focused controllers for each entity or feature.

View Location Issues

Areas have their own view locations. If your views aren't rendering, check that they're in the correct area folder.

Areas/Admin/Views/Dashboard/Index.cshtml

Routing Conflicts

Be explicit with your routes to avoid conflicts between areas and main application routes.

[Area("Admin")]
[Route("admin/[controller]/[action]")]
public class ProductController : Controller
{
    // Accessible at: /admin/product/index
}

Advanced Tips

Area-Specific Layouts

Create area-specific layouts to give different sections of your application distinct looks:

Areas/Admin/Views/Shared/_Layout.cshtml

Authorization by Area

Apply authorization policies at the area level:

[Area("Admin")]
[Authorize(Policy = "AdminOnly")]
public class BaseAdminController : Controller
{
    // All admin controllers inherit from this
}

Conclusion

Areas are one of ASP.NET Core's most underutilised features. They provide a clean, maintainable way to organise large applications without resorting to architectural gymnastics. Before you create that SuperAdminController or implement your own module system, consider whether Areas might be the solution you're looking for.
Next time you start a new ASP.NET Core project that's going to grow beyond a handful of controllers, set up your Areas from the beginning. Your future self (and your team) will thank you.

🚀 Common C# Performance Optimization Myths

Rumen Dimov — Tue, 05 Nov 2024 08:08:22 +0000

🤔 Common Myths That Don't Help

Performance optimization in C# is often misunderstood, leading developers to adopt practices that either have negligible impact or sometimes even hurt performance. Let's explore some common myths and learn what actually works.

1. 🔍 "LINQ is Always Clean and Fast Enough"

LINQ provides elegant and readable code, but it can introduce significant performance overhead. Each LINQ operation potentially creates intermediate collections and unnecessary iterations. While LINQ is excellent for development speed and maintainability, in performance-critical paths it can be a bottleneck.

2. 📏 "Always Pre-size Your Arrays"

Developers often believe that pre-sizing collections always improves performance. While pre-sizing can help when you know the exact size needed, arbitrarily choosing a large initial capacity can waste memory and potentially slow down your application. The built-in growth algorithms in collections like List are well-optimized for most scenarios.

3. 🏗️ "Structs Are Always Better for Performance"

While value types can improve performance by reducing heap allocations and garbage collection, using large structs can actually degrade performance. Every time a struct is passed as a parameter or assigned to a variable, its entire contents are copied. For larger objects, this copying overhead can exceed any benefits from avoiding heap allocation.

⚡ Real Performance Optimizations That Work

1. 🎯 Efficient Memory Management with Span

Span is like a superhero for memory operations! It provides zero-allocation access to memory and eliminates bounds checking in tight loops.

2. 🔑 Proper Value-Based Equality Implementation

Think of this as giving your objects a unique fingerprint. Good hash codes and equality implementations can make collections like Dictionary and HashSet blazing fast!

3. ♻️ Smart Array Pooling

Think of ArrayPool as a recycling center for arrays. Instead of creating new arrays all the time, we can reuse existing ones!

4. 📝 Optimized String Building

StringBuilderCache is like having a personal assistant for string operations. It keeps track of and reuses StringBuilder instances for you!

💡 Pro Tips

🚦 Don't optimize prematurely - profile first!
📏 Measure, don't guess
🎯 Focus on algorithms first, micro-optimizations last
🧪 Always test performance changes with real-world data
📚 Keep learning about new .NET performance features

There is a lot more that can be said and written about performance. In fact, there are books written on that subject but I wanted to share a few quick tips and share some of the common mistakes I have noticed people make. If I have gotten something wrong, please do correct me in the comments below. I always welcome cosntructive criticism, no one is perfect right! :)

Parkinson's Law in Software Development: How to Break the Time-Expansion Trap 🚀

Rumen Dimov — Sun, 27 Oct 2024 07:40:44 +0000

Introduction

"Work expands to fill the time available for its completion." - C. Northcote Parkinson

This simple observation, known as Parkinson's Law, has profound implications for software development. In this guide, we'll explore how this law affects our development processes and learn practical strategies to harness it for better productivity. 🎯

Table of Contents 📑

Understanding Parkinson's Law in Software Development
Common Pitfalls and Their Solutions
Practical Strategies for Time Management
Team Leadership and Project Management
Real-World Implementation
Measuring Success

Understanding Parkinson's Law in Software Development 🤔

The Developer's Dilemma

Have you ever noticed how a "simple" feature that should take a day somehow stretches into a week? Or how your team always seems to finish major releases just before the deadline, regardless of the timeline? That's Parkinson's Law in action.

In software development, this manifests in several ways:

Feature scope gradually expanding ("This authentication system could really use social login...")
Unnecessary optimization of working code ("Let me just refactor this working component...")
Prolonged research phases ("I need to compare all 15 state management libraries...")
Extended debugging sessions ("Let me optimize this function that runs once a day...")
Perfectionism in non-critical areas ("This internal admin panel needs more animations...")

Common Pitfalls and Their Solutions ⚠️

1.The "Just One More Feature" Syndrome

Real Example: A team building an e-commerce checkout page initially planned for basic credit card processing. As time permitted, they kept adding:

PayPal integration
Apple Pay support
Gift card functionality
Multiple card saving
Advanced receipt customization

Solution:

Define MVP clearly: "Credit card processing with email receipt"
List future features separately for Phase 2
Set explicit feature freeze dates
Document scope expansion requests for future sprints

2. The Perfectionism Trap

Real Example: A developer spent three days optimizing a dashboard's loading time from 800ms to 400ms, when:

Users only access it once per day
The business requirement was "under 2 seconds"
Critical bug fixes were pending

Solution:

Define clear acceptance criteria upfront
Set performance budgets based on business needs
Use metrics to justify optimization time
Maintain a prioritized technical debt backlog

Practical Strategies for Time Management ⚡

1. Time Boxing

Real-World Schedule Example:

2. Task Decomposition

Real Example: Breaking down "Implement User Authentication"

Before:
"Add user authentication - 5 days"

After:

Setup authentication routes (4 hours)
- POST /login
- POST /register
- POST /forgot-password
Implement email verification (4 hours)
- Email service integration
- Verification token logic
Password reset flow (4 hours)
- Reset token generation
- Password update logic
Security headers & rate limiting (2 hours)
- CORS configuration
- Rate limiting middleware

Team Leadership and Project Management 👥

1. Setting Realistic Deadlines

Real Example: E-commerce Site Launch

Bad Approach:

"We need the full site in 3 months" → Team rushes, quality suffers

Better Approach:

Month 1: Product catalog + Basic search
Month 2: Shopping cart + Checkout
Month 3: User accounts + Order history
Post-launch: Reviews, wishlists, recommendations

2. Sprint Planning Strategies

Real-World Example:
Two-Week Sprint Structure:

8 days for core features
1 day for testing/QA
1 day for documentation and deployment prep
2 days buffer for unexpected issues

Real-World Implementation 🛠️

Case Study: Blog Platform Development

Original Timeline: 6 weeks
Actual Delivery: 4 weeks

How They Beat Parkinson's Law:

Defined MVP strictly:
- Basic post CRUD
- Simple authentication
- Markdown support
- Basic comments
Moved to Phase 2:
- Social sharing
- Rich text editor
- Analytics
- Tag system
Daily Progress Tracking:
- Morning: Set 3 main goals
- Evening: Review completion
- Document blockers
Fixed Time Blocks:
- 90-minute focused coding sessions
- 15-minute breaks
- No meetings Wednesday & Friday mornings

Measuring Success 📊

Key Metrics to Track

Sprint completion rates
- Target: 85%+ completion
- Track velocity trends
Feature completion time
- Compare estimates vs. actuals
- Document reasons for variances
Technical debt ratio
- Track bugs per feature
- Monitor refactoring needs
Team satisfaction
- Regular pulse checks
- Stress level monitoring
Customer feedback
- User satisfaction scores
- Feature adoption rates

Practical Tips for Implementation 💡

1. The 80/20 Rule in Action

Real Example: Shopping Cart Development

80% Value Features (Implement First):
Add/remove items
Update quantities
Calculate total
Proceed to checkout
20% Value Features (Defer):
Save for later
Share cart
Product recommendations
Recently viewed items

2. Reality Checks

Weekly Team Questions:

1."What features did users actually use this week?"
2."Which optimizations made a measurable impact?"
3."What took longer than expected and why?"
4."What could we have simplified?"

Conclusion 🎉

Understanding and actively managing Parkinson's Law in software development is crucial for successful project delivery. By implementing these strategies, you can help your team maintain focus, deliver value consistently, and avoid the common pitfalls of time expansion.
Hope you enjoyed reading the article. I tried to come up with real world examples. If there is anything I have missed or I have gotten something, please do share and comment.

Action Items

Audit your current project timeline
Implement time-blocking next week
Define strict MVP criteria
Start tracking completion patterns
Schedule weekly reality checks

LINQ Cheatsheet: The Ultimate Guide for Modern .NET Development 🚀

Rumen Dimov — Sun, 27 Oct 2024 06:35:11 +0000

Introduction

LINQ (Language Integrated Query) is a game-changing feature in C# that revolutionizes how we work with data. Whether you're manipulating collections, querying databases, or processing XML, LINQ provides a unified, elegant approach to data manipulation. This comprehensive cheatsheet will boost your productivity with LINQ and help you write more maintainable code.

Table of Contents 📑

Basic LINQ Operations
Filtering and Finding Elements
Ordering and Grouping
Projection Operations
Aggregation Functions
Set Operations
Best Practices and Performance Tips

1.Basic LINQ Operations ⚡

LINQ offers two ways to write queries: query syntax and method syntax. Query syntax might feel more natural for developers coming from SQL backgrounds, while method syntax offers better IntelliSense support and is often more concise. Both approaches are functionally equivalent, so choose the one that makes your code more readable.

Query Syntax vs Method Syntax

2.Filtering and Finding Elements 🔍

Filtering operations are the bread and butter of LINQ. These methods help you search through collections to find specific elements or subsets that match your criteria. Whether you need a single item or multiple items matching certain conditions, LINQ provides precise tools for the job.

Where - Filter Elements

3.Ordering and Grouping 📊

When you need to organize your data, LINQ's ordering and grouping operations come to the rescue. These methods help you sort collections based on one or more criteria and group related items together, perfect for creating hierarchical data structures or preparing data for presentation.

OrderBy and ThenBy

4.Projection Operations 🔄

Projection operations transform your data from one form to another. These are essential for mapping data between different types, extracting specific properties, or flattening nested collections. Think of projection as reshaping your data to match your needs.

Select and SelectMany

5.Aggregation Functions 📈

Aggregation functions help you compute summary values from your collections. Whether you need to count items, calculate averages, or find extreme values, these methods provide a concise way to analyze your data and extract meaningful insights.

Count, Sum, Average, Min, Max

6.Set Operations 🎯

Set operations treat collections as mathematical sets, allowing you to combine, compare, and contrast different collections. These operations are particularly useful when you need to find common elements, unique items, or differences between collections.

Distinct, Union, Intersect, Except

7.Best Practices and Performance Tips ⚡

Understanding these best practices will help you write more efficient LINQ queries and avoid common pitfalls. LINQ's deferred execution model can be both powerful and tricky - knowing how and when queries are executed is crucial for writing performant code.

Deferred Execution ⏳

Use Appropriate Methods 🎯

Avoid Multiple Enumeration ⚠️

Conclusion 🎉

LINQ is an incredibly powerful tool in the .NET ecosystem. This cheatsheet covers the most common operations you'll need in your daily development work. Remember that LINQ's true power lies in its composability – you can chain these operations together to create complex data transformations with clean, readable code.
I hope most of you find this post helpful. Those of you who are more advanced and have a good grasp on LINQ, please do share/comment if I have missed anything. I think there is a lot to say in terms of performance optimization but this is a topic for another post I guess.

P.S. I used Rider JetBrains to write the examples. It is finally free for Non-Commercial use, go check it out if you are fed up with Visual Studio.

Forem: Rumen Dimov

How I Performance Optimised My Next.js App

The Big Plot Twist

My Approach (aka "Does It Feel Fast? 😂")

Images Were Eating My Performance

Fonts Can Block Your Entire Page

Cache Everything That Doesn't Change

Code Splitting Saved My Bundle Size

Tree-Shaking Icons

Database Queries

Skeleton Loaders Are Your Friend 😂

Server Components vs Client Components

The Little Things That Add Up:

Some Honest Thoughts

Areas in ASP.NET Core: The Architectural Feature You're Probably Missing

Introduction

What Are Areas?

Why Areas Matter

1. Logical Organisation

2. Team Collaboration

3. Namespace Separation

4. Route Management

Real-World Example: E-Commerce Application

Implementing Areas

Common Pitfalls and Solutions

The "God Controller" Anti-Pattern

View Location Issues

Routing Conflicts

Advanced Tips

Area-Specific Layouts

Authorization by Area

Conclusion

Further Reading

🚀 Common C# Performance Optimization Myths

🤔 Common Myths That Don't Help

1. 🔍 "LINQ is Always Clean and Fast Enough"

2. 📏 "Always Pre-size Your Arrays"

3. 🏗️ "Structs Are Always Better for Performance"

⚡ Real Performance Optimizations That Work

1. 🎯 Efficient Memory Management with Span

2. 🔑 Proper Value-Based Equality Implementation

3. ♻️ Smart Array Pooling

4. 📝 Optimized String Building

💡 Pro Tips

Parkinson's Law in Software Development: How to Break the Time-Expansion Trap 🚀

Introduction

Table of Contents 📑

Understanding Parkinson's Law in Software Development 🤔

The Developer's Dilemma

Common Pitfalls and Their Solutions ⚠️

1.The "Just One More Feature" Syndrome

2. The Perfectionism Trap

Practical Strategies for Time Management ⚡

1. Time Boxing

2. Task Decomposition

Team Leadership and Project Management 👥

1. Setting Realistic Deadlines

2. Sprint Planning Strategies

Real-World Implementation 🛠️

Case Study: Blog Platform Development

Measuring Success 📊

Key Metrics to Track

Practical Tips for Implementation 💡

1. The 80/20 Rule in Action

2. Reality Checks

Conclusion 🎉

Action Items

LINQ Cheatsheet: The Ultimate Guide for Modern .NET Development 🚀

Introduction

Table of Contents 📑

1.Basic LINQ Operations ⚡

Query Syntax vs Method Syntax

2.Filtering and Finding Elements 🔍

Where - Filter Elements

3.Ordering and Grouping 📊

OrderBy and ThenBy

4.Projection Operations 🔄

Select and SelectMany

5.Aggregation Functions 📈

Count, Sum, Average, Min, Max