Frontend System Design · Lesson 13 of 86 · 4 min
Client-Side Storage: Limits and Security Risks
Knowing the limits and security traps of browser storage separates a junior who knows the APIs from a senior who can be trusted with user data.
How Storage Quotas Will Break Your App
Web Storage is not infinite. Browsers typically grant each origin about 5MB for localStorage and another 5MB for sessionStorage. When you exceed this, the browser will throw an exception, and your app will crash if you haven't handled it.
This isn't a theoretical problem. A feature that caches API responses or a client-side logger can fill this space surprisingly quickly. Users in private browsing or with strict security settings might also have storage disabled entirely.
The trap: Assuming setItem will always succeed.
Never write to localStorage or sessionStorage without a try...catch block. This is non-negotiable for production code.
// theme-manager.ts
type Theme = 'light' | 'dark';
const THEME_KEY = 'user-theme';
/**
* Sets the user's preferred theme in localStorage, with error handling.
*/
export function setUserTheme(theme: Theme): void {
try {
localStorage.setItem(THEME_KEY, theme);
} catch (error) {
console.error("Failed to set theme in localStorage:", error);
// The app should still function, just without persistence.
}
}
/**
* Retrieves the user's theme, defaulting if not found or on error.
*/
export function getUserTheme(): Theme {
try {
const storedTheme = localStorage.getItem(THEME_KEY);
if (storedTheme === 'light' || storedTheme === 'dark') {
return storedTheme;
}
} catch (error) {
console.error("Failed to retrieve theme from localStorage:", error);
}
return 'dark'; // Default theme
}
The Performance Cost of Synchronous Storage
localStorage and sessionStorage have a simple, synchronous API. This simplicity is also their biggest performance liability.
Every call to getItem, setItem, or removeItem is a blocking operation on the browser's main thread. If you're storing a small string, it's unnoticeable. But if you read or write a large JSON object—say, a 1MB user profile—you have to JSON.parse() or JSON.stringify() it. This can easily take several milliseconds, blocking rendering and causing UI jank.
This is why IndexedDB exists. Its asynchronous, promise-based API doesn't block the main thread, making it the only viable choice for storing and retrieving large or numerous pieces of data on the client.
Why Storing Auth Tokens in localStorage is a Trap
Storing a session token (like a JWT) in localStorage is a common pattern, but it's also a significant security risk. Anything in localStorage is accessible to any JavaScript running on the page.
If an attacker can inject a script into your page—a Cross-Site Scripting (XSS) attack—they can read the token from localStorage and send it to their own server. With that token, they can impersonate your user.
The more secure alternative is to store the session token in an HttpOnly cookie. The HttpOnly flag makes the cookie inaccessible to JavaScript, completely mitigating this XSS-based theft vector.
An interviewer asks: "Where do you store a JWT?"
Your answer should start with security. "My default is an
HttpOnly,Secure, andSameSite=Laxcookie.HttpOnlyprevents XSS from accessing the token, andSameSitemitigates CSRF. This is the most secure method for traditional web apps.If the architecture requires JavaScript access—for example, a SPA that must send the token as a Bearer token to a different domain's API—then we might be forced to use
localStorage. In that case, we accept the XSS risk and must be extremely diligent about sanitizing all user input and implementing a strict Content Security Policy (CSP)."
This answer shows you understand the trade-off between security and architectural constraints.
When to Suffer IndexedDB's API
Let's be direct: the IndexedDB API is verbose and complex. You don't use it because you want to; you use it because you have to.
You reach for IndexedDB when you need to build offline-first applications or handle datasets too large for localStorage. Think of apps like Figma, which need to store complex design data locally, or a PWA for a field technician that must function without a network connection.
Its key features justify the complexity:
- Asynchronous: It doesn't block the main thread.
- Large Storage: Quotas are much larger than
localStorage, often in the hundreds of megabytes or even gigabytes, depending on available disk space. - Structured Data: It's a true object store, not just a string-based key-value store. It can index data, allowing for efficient querying.
The practical advice: Don't use the raw IndexedDB API. Use a lightweight wrapper library like idb by Jake Archibald or a more powerful ORM-like library such as Dexie.js. They provide modern, promise-based APIs that are far more pleasant to work with. Mentioning these libraries in an interview shows practical experience.
Try it
Go to a complex web app you use daily (like GitHub, Reddit, or your company's internal dashboard). Open DevTools, go to the Application tab, and inspect its localStorage, sessionStorage, and Cookies. Identify what's being stored. Can you find a session or auth token? If it's in localStorage, you've found a potential XSS vulnerability.
Next: Choose the right client-side storage for the job by combining these constraints into a decision framework.
Lock it in — apply this lesson under interview conditions.