1. Head over to the Firebase Console.
2. Start a new Firebase project or pick one you already have.
3. Turn on the authentication service by going to the "Authentication" section and setting up sign-in methods like Email/Password, Google, etc.

1. Make sure you're in a Node.js environment to install the Firebase Admin SDK.
2. Run this command:
   ```bash
   npm install firebase-admin
   ```
3. Initialize the Admin SDK in your server-side code:
   ```javascript
   const admin = require('firebase-admin');
   admin.initializeApp({
   credential: admin.credential.applicationDefault()
   // Or specify credentials using a service account file:
   // credential: admin.credential.cert(serviceAccount)
   });
   ```

1. Create a function to add custom claims to a user when they register or during any logical event:
   ```javascript
   async function setCustomClaims(uid, claims) {
   try {
   await admin.auth().setCustomUserClaims(uid, claims);
   console.log('Custom claims set successfully');
   } catch (error) {
   console.error('Error setting custom claims:', error);
   }
   }
   ```
2. Example usage:
   ```javascript
   const uid = 'user-unique-id';
   const claims = { admin: true, premiumUser: false };
   setCustomClaims(uid, claims);
   ```

1. In your server-side code, create middleware to verify custom claims:
   ```javascript
   async function verifyCustomClaims(req, res, next) {
   const idToken = req.headers.authorization.split('Bearer ')[1];
   try {
   const decodedToken = await admin.auth().verifyIdToken(idToken);
   if (decodedToken.admin) {
   next();
   } else {
   res.status(403).send('Insufficient permissions');
   }
   } catch (error) {
   res.status(401).send('Invalid or expired token');
   }
   }
   ```

1. Integrate the middleware into your route definitions:
   ```javascript
   const express = require('express');
   const app = express();

   app.use('/admin', verifyCustomClaims, (req, res) => {
   res.send('Welcome, Admin!');
   });

   app.listen(3000, () => {
   console.log('Server is running on port 3000');
   });
   ```

1. Use Firebase Authentication to sign in as a user and get an ID token.
2. Make an HTTP request to your protected route with the obtained ID token.
   ```bash
   curl --header "Authorization: Bearer <ID_TOKEN>" http://localhost:3000/admin
   ```
3. Check the response and make sure only users with the right custom claims can access the route.

1. In your Firebase authentication listener on the client side, handle custom claims:
   ```javascript
   firebase.auth().onAuthStateChanged(async user => {
   if (user) {
   const idTokenResult = await user.getIdTokenResult();
   if (idTokenResult.claims.admin) {
   console.log('User is an admin');
   // Enable admin features
   } else {
   console.log('User is not an admin');
   // Disable admin features
   }
   }
   });
   ```

2. Adjust the UI to reflect user permissions based on the claims:
   ```javascript
   if (idTokenResult.claims.admin) {
   document.getElementById('admin-section').style.display = 'block';
   } else {
   document.getElementById('admin-section').style.display = 'none';
   }
   ```

This step-by-step guide gives you a full picture of how to implement custom claims-based authorization in Firebase, from setting up the project and defining custom claims to protecting routes and updating the frontend.