1. Head over to the Supabase website and either sign up or log in.
2. Create a new project by filling in the necessary details like project name, database password, and region.
3. Once your project is up and running, go to the project dashboard. Here, you'll find your API keys and other configuration details.

1. First, install the Supabase client library in your app:
   ```bash
   npm install @supabase/supabase-js
   ```

2. Next, initialize the Supabase client by adding this code to your main application file:
   ```javascript
   import { createClient } from '@supabase/supabase-js';

   const supabaseUrl = 'https://your-project-ref.supabase.co';
   const supabaseKey = 'public-anon-key';
   const supabase = createClient(supabaseUrl, supabaseKey);
   ```

1. In the Supabase dashboard, go to the SQL editor and run this SQL script to create a notifications table:
   ```sql
   create table notifications (
   id serial primary key,
   user_id uuid references auth.users(id),
   message text not null,
   is_read boolean default false,
   created_at timestamp default current_timestamp
   );
   ```

1. Create a function in your app to insert a new notification into the notifications table:
   ```javascript
   async function sendNotification(userId, message) {
   const { data, error } = await supabase
   .from('notifications')
   .insert([{ user_id: userId, message: message }]);
   if (error) {
   console.error('Error sending notification:', error);
   } else {
   console.log('Notification sent:', data);
   }
   }
   ```

1. Create a function in your app to fetch notifications for a user:
   ```javascript
   async function getNotifications(userId) {
   const { data, error } = await supabase
   .from('notifications')
   .select('*')
   .eq('user_id', userId)
   .order('created_at', { ascending: false });
   if (error) {
   console.error('Error fetching notifications:', error);
   } else {
   console.log('User notifications:', data);
   }
   }
   ```

1. Create a function to update the is_read field for a notification:
   ```javascript
   async function markAsRead(notificationId) {
   const { data, error } = await supabase
   .from('notifications')
   .update({ is_read: true })
   .eq('id', notificationId);
   if (error) {
   console.error('Error marking notification as read:', error);
   } else {
   console.log('Notification marked as read:', data);
   }
   }
   ```

1. Use Supabase's real-time features to listen for changes in the notifications table:
   ```javascript
   supabase
   .from('notifications')
   .on('INSERT', payload => {
   console.log('New notification:', payload.new);
   // Update UI or notify user
   })
   .subscribe();
   ```

1. Fetch and display notifications in the user interface:
   ```javascript
   async function displayNotifications(userId) {
   const notifications = await getNotifications(userId);
   // Render notifications in the UI
   notifications.forEach(notification => {
   // e.g., create a notification element and append to a notification container
   });
   }

   // Call the function when needed
   displayNotifications(currentUser.id);
   ```

2. Make sure the real-time listener updates the UI when a new notification comes in.

By following these steps, you can set up a notification system using Supabase.