Developer Cheatsheets
Shipping Fast
IV: Getting it Bulletproof

Pass Four: Bulletproof It

Objective: It's tough, handles failure with grace.

This stage revolves around considering error management, edge cases, and the user's experience when things don't quite pan out as planned. Applying this to our case study, this could mean managing instances where the user data couldn't be retrieved, or perhaps the data returned in an unexpected configuration.

Here's a peek at what this might appear like in the code:

// hooks/useUser.tsx
import { useState, useEffect } from 'react';
import fetchUser from '../services/fetchUser';
interface User {
  name: string;
  // other user properties...
const useUser = (userId: string) => {
  const [user, setUser] = useState<User | null>(null);
  const [error, setError] = useState<string | null>(null);
  useEffect(() => {
    const loadUser = async () => {
      try {
        const userData = await fetchUser(userId);
      } catch (err) {
        setError('Failed to load user data');
  }, [userId]);
  return { user, error };
export default useUser;
// components/UserProfile.tsx
import React from 'react';
import useUser from '../hooks/useUser';
interface UserProfileProps {
  userId: string;
const UserProfile: React.FC<UserProfileProps> = ({ userId }) => {
  const { user, error } = useUser(userId);
  if (error) {
    return <div>Error: {error}</div>;
  return (
      {/* More user info here... */}
export default UserProfile;

In the given example, we've incorporated error handling into the fetchUser function within our custom hook, and the hook now returns an error state in conjunction with the user state. The UserProfile component is then capable of displaying an error message to the user if things go awry. This fortifies our application and elevates the user experience.

Keep in mind, it's not obligatory to adhere to these passes sequentially or just once. It's more akin to a cyclical process where you perpetually refine and augment your code over time. You might journey through numerous cycles of "get it done", then "make it right", then "polish the edges", then "bulletproof it" as you flesh out an application.