diff --git a/client/src/pages/Landing.tsx b/client/src/pages/Landing.tsx
index ba57e22..5fed733 100644
--- a/client/src/pages/Landing.tsx
+++ b/client/src/pages/Landing.tsx
@@ -1,5 +1,5 @@
 import React, { useContext } from 'react';
-import { createConnection } from '../utils/socket-client';
+import { openSessionSocket } from '../utils/session-socket-client';
 import { RouteComponentProps, withRouter } from 'react-router-dom';
 import { SocketContext } from '../App';
 import CreateSessionForm from '../components/CreateSessionForm';
@@ -13,10 +13,14 @@ const { TabPane } = Tabs;
 const Landing = (props: RouteComponentProps & any) => {
   const { setClientId, setClientDisplayName } = useContext(SocketContext);
 
-  const startSession = async (
-    { displayName, roomType }: { displayName: string, roomType: string }
-  ) => {
-    const newSocket = await createConnection(displayName, roomType, true);
+  const startSession = async ({
+    displayName,
+    roomType,
+  }: {
+    displayName: string;
+    roomType: string;
+  }) => {
+    const newSocket = await openSessionSocket(displayName, roomType, true);
 
     setClientId(newSocket.id);
     setClientDisplayName(displayName);
diff --git a/client/src/pages/Room.tsx b/client/src/pages/Room.tsx
index f411c9b..88fafdf 100644
--- a/client/src/pages/Room.tsx
+++ b/client/src/pages/Room.tsx
@@ -1,6 +1,10 @@
 import React, { useState, useEffect, useContext } from 'react';
 import { RouteComponentProps, withRouter, useHistory } from 'react-router-dom';
-import { createConnection, roomSocketEvents } from '../utils/socket-client';
+import {
+  openSessionSocket,
+  subscribeToRoomEvents,
+} from '../utils/session-socket-client';
+import { openRtcSocket } from '../utils/rtc-socket-client';
 import { SocketContext } from '../App';
 import Video from '../components/Video';
 import { ClientContext } from '../contexts/clientContext';
@@ -11,7 +15,19 @@ import Playlist from '../components/Playlist';
 import RoomParticipants from '../components/RoomParticipants';
 import { MediasoupPeer } from '../utils/MediasoupPeer';
 
-import { Row, Col, Modal, Form, Input, Button, Select, Alert, Space, notification, Spin } from 'antd';
+import {
+  Row,
+  Col,
+  Modal,
+  Form,
+  Input,
+  Button,
+  Select,
+  Alert,
+  Space,
+  notification,
+  Spin,
+} from 'antd';
 import roomStyles from '../styles/pages/room.module.scss';
 const { Option } = Select;
 
@@ -53,14 +69,18 @@ const Room = ({ location, match }: RoomProps & any) => {
       ? [{ id: clientId, name: clientDisplayName, isMuted: false }]
       : []
   );
-  const [waitingClients, setWaitingClients] = useState<{[socketId: string]: string}>({});
+  const [waitingClients, setWaitingClients] = useState<{
+    [socketId: string]: string;
+  }>({});
 
   const [enterDisplayName, setEnterDisplayName] = useState(false);
   const [isMuted, setIsMuted] = useState(false);
   const [selectNewAudio, setSelectNewAudio] = useState(false);
   const [canEnter, setCanEnter] = useState(clientId ? true : false);
 
-  const [socket, setSocket] = useState(location.socket ? location.socket : {});
+  const [sessionSocket, setSessionSocket] = useState(
+    location.socket ? location.socket : {}
+  );
   const [mediasoupPeer, setMediasoupPeer] = useState<MediasoupPeer>();
   const [audioDevices, setAudioDevices] = useState<AudioDevice[]>([]);
   const [selectedAudioDevice, setSelectedAudioDevice] = useState<{
@@ -91,47 +111,53 @@ const Room = ({ location, match }: RoomProps & any) => {
         youtubeID: roomYoutubeId,
       });
       setCanEnter(true);
-      setHostEvents(location.socket);
-      setWaitingRoomEvents(location.socket);
-      updateClientList(location.socket);
-      setSocket(location.socket);
-      roomSocketEvents(location.socket, dispatches);
-      await startAudioCall(location.socket);
+      attachHostNotifs(location.socket);
+      setSessionSocket(location.socket);
+      subscribeToHostEvents(location.socket);
+      subscribeToClientListUpdates(location.socket);
+      subscribeToRoomEvents(location.socket, dispatches);
+      await startAudioCall(location.socket.id);
     }
-    // Joining client from landing, inputted displayName, or Room client 
+    // Joining client from landing, inputted displayName, or Room client
     // that already made connection and refreshed
-    else if ((!clientId && clientDisplayName) || (clientId && clientDisplayName)) {
+    else if (
+      (!clientId && clientDisplayName) ||
+      (clientId && clientDisplayName)
+    ) {
       const { roomId } = match.params;
-      const socketConnection = await createConnection(
+      const socketConnection = await openSessionSocket(
         clientDisplayName,
         '',
         canEnter,
         roomId
       );
-      setSocket(socketConnection);
+      setSessionSocket(socketConnection);
 
       if (canEnter) {
         await enterRoom(socketConnection);
-      }
-      else {
+      } else {
         socketConnection.on('accept', async () => {
           rejoinSocket(roomId, socketConnection);
           setCanEnter(true);
           await enterRoom(socketConnection);
         });
-        socketConnection.on('decline', () => history.push('/'));
+        socketConnection.on('decline', () => {
+          socketConnection.disconnect();
+          history.push('/');
+        });
 
-        const callback = async (roomType: string) => {
-          if (roomType !== 'private') {
-            rejoinSocket(roomId, socketConnection);
-            await enterRoom(socketConnection);
-          }
+        const admitClient = async () => {
+          rejoinSocket(roomId, socketConnection);
+          await enterRoom(socketConnection);
         };
-
-        socketConnection.emit('getRoomType', {
-          clientName: clientDisplayName,
-          roomId
-        }, callback);
+        socketConnection.emit(
+          'getRoomType',
+          {
+            clientName: clientDisplayName,
+            roomId,
+          },
+          admitClient
+        );
       }
     }
     // Joining client from direct URL, prompt for displayName
@@ -140,14 +166,17 @@ const Room = ({ location, match }: RoomProps & any) => {
     }
   };
 
-  // Subscribes to updateClientList broadcasts from WebSocketServer
-  const updateClientList = (connectingSocket: SocketIOClient.Socket) => {
+  const subscribeToClientListUpdates = (
+    connectingSocket: SocketIOClient.Socket
+  ) => {
     connectingSocket.on('updateClientList', (newClientList: Client[]) => {
       setClients(newClientList);
     });
   };
 
-  const updatePlaylist = (connectingSocket: SocketIOClient.Socket) => {
+  const subscribeToPlaylistUpdates = (
+    connectingSocket: SocketIOClient.Socket
+  ) => {
     connectingSocket.on('updatePlaylist', (newPlaylist: string[]) => {
       clientDispatch({
         type: ClientStates.DELETE_VIDEO,
@@ -156,71 +185,79 @@ const Room = ({ location, match }: RoomProps & any) => {
     });
   };
 
-  const handleFormSubmit = (displayNameInput: string) => {
-    setClientDisplayName(displayNameInput);
-    setEnterDisplayName(false);
-  };
-
-  const rejoinSocket = (roomId: string, connectingSocket: SocketIOClient.Socket) => {
-    setCanEnter(true);
-    const clientData = {
-      roomId,
-      clientId: connectingSocket.id,
-      clientName: clientDisplayName,
-      roomType: '',
-      canJoin: true
-    };
-
-    connectingSocket.emit('join', clientData);
-  };
-
-  const setWaitingRoomEvents = (connectingSocket: SocketIOClient.Socket) => {
+  const subscribeToHostEvents = (connectingSocket: SocketIOClient.Socket) => {
     connectingSocket.on('newHost', (hostName: string, hostId: string) => {
       notification.open({
         message: 'New Host',
-        description:
-          `${connectingSocket.id !== hostId ? `${hostName} is` : 'You are'} now the host`,
-        duration: 8
+        description: `${
+          connectingSocket.id !== hostId ? `${hostName} is` : 'You are'
+        } now the host`,
+        duration: 8,
       });
 
       if (connectingSocket.id === hostId) {
-        setHostEvents(connectingSocket);
+        attachHostNotifs(connectingSocket);
       }
     });
   };
 
-  const setHostEvents = (connectingSocket: SocketIOClient.Socket) => {
-    connectingSocket.on('waitingClient', (
-      { socketId, clientName }: {socketId: string, clientName: string}
-    ) => {
-      setWaitingClients({
-        ...waitingClients,
-        [socketId]: clientName
-      });
-    });
-
-    connectingSocket.on('updateWaitingClients', (
-      { waitingClientList, clientIdLeft }: {
-        waitingClientList: {[socketId: string]: string},
-        clientIdLeft: string
+  const attachHostNotifs = (connectingSocket: SocketIOClient.Socket) => {
+    connectingSocket.on(
+      'waitingClient',
+      ({
+        waitingClients,
+      }: {
+        waitingClients: { [socketId: string]: string };
       }) => {
-      setWaitingClients(waitingClientList);
-      if (clientIdLeft.length > 0) notification.close(clientIdLeft);
-    });
+        setWaitingClients(waitingClients);
+      }
+    );
+
+    connectingSocket.on(
+      'updateWaitingClients',
+      ({
+        waitingClientList,
+        clientIdLeft,
+      }: {
+        waitingClientList: { [socketId: string]: string };
+        clientIdLeft: string;
+      }) => {
+        setWaitingClients(waitingClientList);
+        if (clientIdLeft.length > 0) notification.close(clientIdLeft);
+      }
+    );
+  };
+
+  const rejoinSocket = (
+    roomId: string,
+    connectingSocket: SocketIOClient.Socket
+  ) => {
+    setCanEnter(true);
+    const clientData = {
+      roomId,
+      clientId: connectingSocket.id,
+      clientName: clientDisplayName,
+      roomType: '',
+      canJoin: true,
+    };
+
+    connectingSocket.emit('join', clientData);
   };
 
   const enterRoom = async (connectingSocket: SocketIOClient.Socket) => {
-    setWaitingRoomEvents(connectingSocket);
     setClientId(connectingSocket.id);
-    updateClientList(connectingSocket);
-    updatePlaylist(connectingSocket);
-    roomSocketEvents(connectingSocket, dispatches);
-    await startAudioCall(connectingSocket);
+    subscribeToHostEvents(connectingSocket);
+    subscribeToClientListUpdates(connectingSocket);
+    subscribeToPlaylistUpdates(connectingSocket);
+    subscribeToRoomEvents(connectingSocket, dispatches);
+    await startAudioCall(connectingSocket.id);
   };
 
-  const startAudioCall = async (socket: SocketIOClient.Socket) => {
+  const startAudioCall = async (redisClientId: string) => {
+    const { roomId } = match.params;
+    const rtcSocket = await openRtcSocket(roomId, redisClientId);
     const deviceId = await setMediaDevices();
-    await startMediasoup(socket, deviceId);
+    await startMediasoup(rtcSocket, deviceId);
   };
 
   const setMediaDevices = async () => {
@@ -242,10 +279,10 @@ const Room = ({ location, match }: RoomProps & any) => {
   };
 
   const startMediasoup = async (
-    socket: SocketIOClient.Socket,
+    rtcSocket: SocketIOClient.Socket,
     audioDeviceId: string
   ) => {
-    const peer = new MediasoupPeer(socket, remoteAudiosDiv);
+    const peer = new MediasoupPeer(rtcSocket, remoteAudiosDiv);
     setMediasoupPeer(peer);
     await peer.init();
     await peer.produce(audioDeviceId);
@@ -280,10 +317,15 @@ const Room = ({ location, match }: RoomProps & any) => {
 
     const newClients = clients;
     for (const client of newClients) {
-      if (socket.id === client.id) client.isMuted = !client.isMuted;
+      if (sessionSocket.id === client.id) client.isMuted = !client.isMuted;
     }
     setClients(newClients);
-    socket.emit('mute', { id: socket.id });
+    sessionSocket.emit('mute', { id: sessionSocket.id });
+  };
+
+  const handleFormSubmit = (displayNameInput: string) => {
+    setClientDisplayName(displayNameInput);
+    setEnterDisplayName(false);
   };
 
   const handleSelectAudioModal = () => {
@@ -294,7 +336,7 @@ const Room = ({ location, match }: RoomProps & any) => {
     const newWaitingClients = waitingClients;
     delete newWaitingClients[socketId];
     setWaitingClients(newWaitingClients);
-    socket.emit('waitingResponse', { socketId, status });
+    sessionSocket.emit('waitingResponse', { socketId, status });
     notification.close(socketId);
   };
 
@@ -327,38 +369,37 @@ const Room = ({ location, match }: RoomProps & any) => {
       ) : !canEnter ? (
         <div className={roomStyles.waiting}>
           <h1>Please wait while the host lets you in</h1>
-          <Spin size="large"/>
+          <Spin size="large" />
         </div>
       ) : (
         <div>
           <div id="remoteAudios" />
-          {selectNewAudio &&
-            selectedAudioDevice.deviceId && (
-              <Modal
-                title="Select a new input device"
-                onCancel={handleSelectAudioModal}
-                visible={selectNewAudio}
-                footer={null}
-                centered
-              >
-                <div className={roomStyles.audio__modal}>
-                  <Select
-                    defaultValue={audioDevices[0].deviceName}
-                    onChange={handleAudioSelect}
-                  >
-                    {audioDevices.map((audioDevice) => (
-                      <Option
-                        key={audioDevice.deviceName}
-                        value={audioDevice.deviceId}
-                      >
-                        {audioDevice.deviceName}
-                      </Option>
-                    ))}
-                  </Select>
-                </div>
-              </Modal>
-            )}
-          {Object.keys(waitingClients).map((socketId) => (
+          {selectNewAudio && selectedAudioDevice.deviceId && (
+            <Modal
+              title="Select a new input device"
+              onCancel={handleSelectAudioModal}
+              visible={selectNewAudio}
+              footer={null}
+              centered
+            >
+              <div className={roomStyles.audio__modal}>
+                <Select
+                  defaultValue={audioDevices[0].deviceName}
+                  onChange={handleAudioSelect}
+                >
+                  {audioDevices.map((audioDevice) => (
+                    <Option
+                      key={audioDevice.deviceName}
+                      value={audioDevice.deviceId}
+                    >
+                      {audioDevice.deviceName}
+                    </Option>
+                  ))}
+                </Select>
+              </div>
+            </Modal>
+          )}
+          {Object.keys(waitingClients).map((socketId) =>
             notification.open({
               key: socketId,
               message: 'Waiting Room Notification',
@@ -377,7 +418,8 @@ const Room = ({ location, match }: RoomProps & any) => {
                       </Button>
                       <Button
                         size="small"
-                        danger type="ghost"
+                        danger
+                        type="ghost"
                         onClick={() => handleNotification(socketId, 'decline')}
                       >
                         Decline
@@ -388,9 +430,9 @@ const Room = ({ location, match }: RoomProps & any) => {
               ),
               placement: 'topRight',
               duration: 0,
-              closeIcon : (<div/>),
+              closeIcon: <div />,
             })
-          ))}
+          )}
 
           <Row gutter={16} className={roomStyles.main__content}>
             <Col sm={16} className={roomStyles.left__col}>
@@ -400,11 +442,11 @@ const Room = ({ location, match }: RoomProps & any) => {
                 handleMute={handleMute}
                 handleSelectAudioModal={handleSelectAudioModal}
               />
-              <Video youtubeID={clientData.youtubeID} socket={socket} />
-              <Playlist socket={socket} />
+              <Video youtubeID={clientData.youtubeID} socket={sessionSocket} />
+              <Playlist socket={sessionSocket} />
             </Col>
             <Col sm={8} className={roomStyles.chat__col}>
-              <Chat socket={socket} />
+              <Chat socket={sessionSocket} />
             </Col>
           </Row>
         </div>
diff --git a/client/src/utils/MediasoupPeer.ts b/client/src/utils/MediasoupPeer.ts
index c52d843..42cca37 100644
--- a/client/src/utils/MediasoupPeer.ts
+++ b/client/src/utils/MediasoupPeer.ts
@@ -1,6 +1,5 @@
 import { mediasoupEvent } from './helpers';
 import { Device, types as mediasoupType } from 'mediasoup-client';
-import { Client } from '../../../server/utils/Rooms';
 
 export class MediasoupPeer {
   private socket: SocketIOClient.Socket;
@@ -11,10 +10,13 @@ export class MediasoupPeer {
   private consumerTransport: mediasoupType.Transport | undefined;
   private producerId: string | undefined;
   private remoteAudiosDiv: HTMLElement | null;
-  private tempClients: Client[] | undefined;
+  private tempClients: string[] | undefined;
 
-  constructor(socket: SocketIOClient.Socket, remoteAudiosDiv: HTMLElement | null) {
-    this.socket = socket;
+  constructor(
+    rtcSocket: SocketIOClient.Socket,
+    remoteAudiosDiv: HTMLElement | null
+  ) {
+    this.socket = rtcSocket;
     this.device = undefined;
     this.producerTransport = undefined;
     this.consumerTransport = undefined;
@@ -32,49 +34,56 @@ export class MediasoupPeer {
   }
 
   initMediasoupData = async () => {
-    const rtpCapabilities = await mediasoupEvent(this.socket, 'getRtpCapabilities');
+    const rtpCapabilities = await mediasoupEvent(
+      this.socket,
+      'getRtpCapabilities'
+    );
     await this.createDevice(rtpCapabilities);
     await this.createProducerTransport();
     await this.createConsumerTransport();
     this.socket.emit('getProducers');
-  }
+  };
 
   initSocket() {
-    this.socket.on('consumerClosed', (
-      { consumerId }: { consumerId: string }
-    ) => {
-      this.removeConsumer(consumerId);
-    });
+    this.socket.on(
+      'consumerClosed',
+      ({ consumerId }: { consumerId: string }) => {
+        this.removeConsumer(consumerId);
+      }
+    );
 
-    this.socket.on('newProducers', async (
-      data: { producerId: string }[]
-    ) => {
+    this.socket.on('newProducers', async (data: { producerId: string }[]) => {
       for (const { producerId } of data) {
         await this.consume(producerId);
       }
     });
 
-    this.socket.on('activeSpeaker', ({
-      clientVolumes,
-      clients
-    }: {
-      clientVolumes: {[clientId: string]: number},
-      clients: Client[]
-    }) => {
-      if (clients === undefined && this.tempClients === undefined) return;
-      if (clients !== undefined) this.tempClients = clients;
-
-      this.tempClients?.forEach((client) => {
-        const speakerAvatar: any = document.getElementsByClassName(client.id)[0];
-        if (clientVolumes !== null && (client.id in clientVolumes)) {
-          speakerAvatar.style.backgroundColor = '#87d068';
-        }
-        else {
-          if (speakerAvatar !== undefined) speakerAvatar.style = null;
-        }
-      });
-    });
+    this.socket.on(
+      'activeSpeaker',
+      ({
+        clientVolumes,
+        clients,
+      }: {
+        clientVolumes: { [clientId: string]: number };
+        clients: string[];
+      }) => {
+        if (clients === undefined && this.tempClients === undefined) return;
+        if (clients !== undefined) this.tempClients = clients;
+
+        this.tempClients?.forEach((redisClientId) => {
+          const speakerAvatar: any = document.getElementsByClassName(
+            redisClientId
+          )[0];
+          if (clientVolumes !== null && redisClientId in clientVolumes) {
+            speakerAvatar.style.backgroundColor = '#87d068';
+          } else {
+            if (speakerAvatar !== undefined) speakerAvatar.style = null;
+          }
+        });
+      }
+    );
 
+    // Runs only when rtc-server is taken down
     this.socket.on('disconnect', () => {
       this.consumerTransport?.close();
       this.producerTransport?.close();
@@ -84,19 +93,17 @@ export class MediasoupPeer {
     });
   }
 
-  createDevice = async (
-    rtpCapabilities: mediasoupType.RtpCapabilities
-  ) => {
-    const device =  new Device();
+  createDevice = async (rtpCapabilities: mediasoupType.RtpCapabilities) => {
+    const device = new Device();
     await device.load({ routerRtpCapabilities: rtpCapabilities });
     this.device = device;
-  }
+  };
 
   createProducerTransport = async () => {
     if (this.device !== undefined) {
       const transport = await mediasoupEvent(this.socket, 'createTransport', {
         forceTcp: false,
-        rtpCapabilities: this.device.rtpCapabilities
+        rtpCapabilities: this.device.rtpCapabilities,
       });
 
       if (transport.error) throw new Error(transport.error);
@@ -105,47 +112,52 @@ export class MediasoupPeer {
         id: transport.id,
         iceParameters: transport.iceParams,
         iceCandidates: transport.iceCandidates,
-        dtlsParameters: transport.dtlsParameters
+        dtlsParameters: transport.dtlsParameters,
       });
 
       if (this.producerTransport === undefined) {
         throw new Error('producer transport is undefined');
       }
 
-      this.producerTransport.on('connect', async ({
-        dtlsParameters
-      }, callback, errorback) => {
-        await mediasoupEvent(this.socket, 'connectTransport', {
-          transportId: transport.id,
-          dtlsParameters
-        });
-        try {
-          callback();
-        } catch (error) {
-          errorback(error);
+      this.producerTransport.on(
+        'connect',
+        async ({ dtlsParameters }, callback, errorback) => {
+          await mediasoupEvent(this.socket, 'connectTransport', {
+            transportId: transport.id,
+            dtlsParameters,
+          });
+          try {
+            callback();
+          } catch (error) {
+            errorback(error);
+          }
         }
-      });
-
-      this.producerTransport.on('produce', async ({
-        kind,
-        rtpParameters
-      }, callback, errorback) => {
-        try {
-          if (this.producerTransport === undefined) {
-            throw new Error('producer transport is undefined');
+      );
+
+      this.producerTransport.on(
+        'produce',
+        async ({ kind, rtpParameters }, callback, errorback) => {
+          try {
+            if (this.producerTransport === undefined) {
+              throw new Error('producer transport is undefined');
+            }
+
+            const { producerId } = await mediasoupEvent(
+              this.socket,
+              'produce',
+              {
+                producerTransportId: this.producerTransport.id,
+                mediaType: kind,
+                rtpParameters,
+              }
+            );
+
+            callback({ id: producerId });
+          } catch (error) {
+            errorback(error);
           }
-
-          const { producerId } = await mediasoupEvent(this.socket, 'produce', {
-            producerTransportId: this.producerTransport.id,
-            mediaType: kind,
-            rtpParameters
-          });
-
-          callback({ id: producerId });
-        } catch (error) {
-          errorback(error);
         }
-      });
+      );
 
       this.producerTransport.on('connectionstatechange', async (state) => {
         if (state === 'failed') {
@@ -156,13 +168,15 @@ export class MediasoupPeer {
         }
       });
     } else {
-      throw new Error('Device is undefined. There\'s a problem with creating device');
+      throw new Error(
+        "Device is undefined. There's a problem with creating device"
+      );
     }
-  }
+  };
 
   createConsumerTransport = async () => {
     const transport = await mediasoupEvent(this.socket, 'createTransport', {
-      forceTcp: false
+      forceTcp: false,
     });
 
     if (transport.error) {
@@ -176,26 +190,27 @@ export class MediasoupPeer {
       id: transport.id,
       iceParameters: transport.iceParams,
       iceCandidates: transport.iceCandidates,
-      dtlsParameters: transport.dtlsParameters
+      dtlsParameters: transport.dtlsParameters,
     });
 
     if (this.consumerTransport === undefined) {
       throw new Error('consumer transport is undefined');
     }
 
-    this.consumerTransport.on('connect', async ({
-      dtlsParameters
-    }, callback, errorback) => {
-      await mediasoupEvent(this.socket, 'connectTransport', {
-        transportId: this.consumerTransport?.id,
-        dtlsParameters
-      });
-      try {
-        callback();
-      } catch (error) {
-        errorback(error);
+    this.consumerTransport.on(
+      'connect',
+      async ({ dtlsParameters }, callback, errorback) => {
+        await mediasoupEvent(this.socket, 'connectTransport', {
+          transportId: this.consumerTransport?.id,
+          dtlsParameters,
+        });
+        try {
+          callback();
+        } catch (error) {
+          errorback(error);
+        }
       }
-    });
+    );
 
     this.consumerTransport.on('connectionstatechange', async (state) => {
       if (state === 'failed') {
@@ -205,25 +220,28 @@ export class MediasoupPeer {
         this.consumerTransport.close();
       }
     });
-
-  }
+  };
 
   // ----------------------------- MAIN FUNCTIONS -----------------------------
   produce = async (deviceId: string) => {
     const mediaConstraints = {
       audio: { deviceId },
-      video: false
+      video: false,
     };
 
     try {
-      const userMedia = await navigator.mediaDevices.getUserMedia(mediaConstraints);
+      const userMedia = await navigator.mediaDevices.getUserMedia(
+        mediaConstraints
+      );
       const audioTrack: MediaStreamTrack = userMedia.getAudioTracks()[0];
       if (this.producerTransport === undefined) {
         throw new Error('producer transport is undefined');
       }
 
       // Tell transport to send audio tracks to mediasoup router
-      const producer = await this.producerTransport.produce({ track: audioTrack });
+      const producer = await this.producerTransport.produce({
+        track: audioTrack,
+      });
       this.producers.set(producer.id, producer);
 
       producer.on('transportclose', () => {
@@ -242,7 +260,7 @@ export class MediasoupPeer {
     } catch (error) {
       throw new Error(error);
     }
-  }
+  };
 
   consume = async (producerId: string) => {
     const { consumer, audioStream } = await this.getConsumeStream(producerId);
@@ -265,9 +283,11 @@ export class MediasoupPeer {
     consumer.on('transportclose', () => {
       this.removeConsumer(consumer.id);
     });
-  }
+  };
 
-  getConsumeStream = async (producerId: string): Promise<{
+  getConsumeStream = async (
+    producerId: string
+  ): Promise<{
     consumer: mediasoupType.Consumer;
     audioStream: MediaStream;
   }> => {
@@ -279,8 +299,9 @@ export class MediasoupPeer {
       {
         rtpCapabilities,
         consumerTransportId: this.consumerTransport?.id,
-        producerId
-      });
+        producerId,
+      }
+    );
 
     if (this.consumerTransport === undefined) {
       throw new Error('Consumer transport is undefined');
@@ -290,7 +311,7 @@ export class MediasoupPeer {
       id: consumerId,
       producerId,
       rtpParameters,
-      kind: mediaKind
+      kind: mediaKind,
     });
 
     if (consumer === undefined) throw new Error('Consumer is undefined');
@@ -298,23 +319,29 @@ export class MediasoupPeer {
     audioStream.addTrack(consumer.track);
     return {
       consumer,
-      audioStream
+      audioStream,
     };
-  }
+  };
 
   closeProducer = () => {
     // If muted and is selecting a different audio device
     if (this.producerId === undefined) return;
 
-    this.socket.emit('producerClosed', { producerId: this.producerId });
-    if (this.producers.get(this.producerId) === undefined) throw new Error('Producer map is undefined');
+    this.socket.emit('producerClosed', {
+      producerId: this.producerId,
+    });
+    if (this.producers.get(this.producerId) === undefined) {
+      throw new Error('Producer map is undefined');
+    }
     this.producers.get(this.producerId)?.close();
     this.producers.delete(this.producerId);
     this.producerId = undefined;
-  }
+  };
 
   removeConsumer = (consumerId: string) => {
-    const consumerElem: HTMLAudioElement  = document.getElementById(consumerId) as HTMLAudioElement;
+    const consumerElem: HTMLAudioElement = document.getElementById(
+      consumerId
+    ) as HTMLAudioElement;
     if (consumerElem === null) throw new Error('Consumer element is null');
 
     // getTracks() doesn't work with MediaProvider or MediaStream so the any type is specified
@@ -325,5 +352,5 @@ export class MediasoupPeer {
 
     consumerElem?.parentNode?.removeChild(consumerElem);
     this.consumers.delete(consumerId);
-  }
+  };
 }
diff --git a/client/src/utils/helpers.ts b/client/src/utils/helpers.ts
index 95ff5e1..ecea1fa 100644
--- a/client/src/utils/helpers.ts
+++ b/client/src/utils/helpers.ts
@@ -15,7 +15,8 @@ export const validVideoURL = (url: string) => {
 
 export const mediasoupEvent = async (
   socket: SocketIOClient.Socket,
-  event: string, data = {}
+  event: string,
+  data = {}
 ): Promise<any> => {
   return new Promise((resolve) => {
     socket.emit(event, data, resolve);
diff --git a/client/src/utils/rtc-socket-client.ts b/client/src/utils/rtc-socket-client.ts
new file mode 100644
index 0000000..7665d6d
--- /dev/null
+++ b/client/src/utils/rtc-socket-client.ts
@@ -0,0 +1,22 @@
+import io from 'socket.io-client';
+const rtcServerDomain = 'http://localhost:4000';
+
+export const openRtcSocket = (
+  roomId: string,
+  // the id of session socket. allows 1:1 mapping from voice server to session server
+  redisClientId: string
+): Promise<SocketIOClient.Socket> => {
+  return new Promise((resolve) => {
+    const socket = io(rtcServerDomain);
+
+    socket.on('connect', () => {
+      const clientData = {
+        roomId: roomId ? roomId : socket.id,
+        redisClientId,
+      };
+
+      socket.emit('join', clientData);
+      resolve(socket);
+    });
+  });
+};
diff --git a/client/src/utils/socket-client.ts b/client/src/utils/session-socket-client.ts
similarity index 91%
rename from client/src/utils/socket-client.ts
rename to client/src/utils/session-socket-client.ts
index d856f89..050d0be 100644
--- a/client/src/utils/socket-client.ts
+++ b/client/src/utils/session-socket-client.ts
@@ -1,26 +1,25 @@
 import { Dispatch } from 'react';
 import io from 'socket.io-client';
 import { ClientStates, VideoStates } from './enums';
-const socketServerDomain = 'http://localhost:5000';
+const sessionServerDomain = 'http://localhost:5000';
 
 // Establishes a WebSocket connection and resolves the socket object
-export const createConnection = (
+export const openSessionSocket = (
   displayName: string,
   roomType: string,
   canJoin: boolean,
   roomId?: string
 ): Promise<SocketIOClient.Socket> => {
   return new Promise((resolve) => {
-    const socket = io(socketServerDomain);
+    const socket = io(sessionServerDomain);
 
     socket.on('connect', () => {
       const clientData = {
         roomId: roomId ? roomId : socket.id,
-        // if a clientID is present in sessionStorage, use it again
         clientId: socket.id,
         clientName: displayName,
         roomType,
-        canJoin
+        canJoin,
       };
 
       socket.emit('join', clientData);
@@ -34,7 +33,7 @@ interface DispatchTypes {
   videoDispatch: Dispatch<any>;
 }
 
-export const roomSocketEvents = (
+export const subscribeToRoomEvents = (
   socket: SocketIOClient.Socket,
   dispatch: DispatchTypes
 ) => {
diff --git a/client/tslint.json b/client/tslint.json
index e968c06..b4a8853 100644
--- a/client/tslint.json
+++ b/client/tslint.json
@@ -8,7 +8,7 @@
   ],
   "jsRules": {},
   "rules": {
-    "quotemark": [true, "single", "jsx-double"],
+    "quotemark": false,
     "trailing-comma": [false],
     "object-literal-shorthand": true,
     "object-shorthand-properties-first": false,
@@ -24,7 +24,8 @@
     "align": false,
     "brace-style": false,
     "no-duplicate-imports": false,
-    "no-shadowed-variable": false
+    "no-shadowed-variable": false,
+    "semicolon": false
   },
   "rulesDirectory": []
 }
diff --git a/server/mediasoup-config.ts b/rtc-server/mediasoup-config.ts
similarity index 69%
rename from server/mediasoup-config.ts
rename to rtc-server/mediasoup-config.ts
index 80d4ddd..4b30db5 100644
--- a/server/mediasoup-config.ts
+++ b/rtc-server/mediasoup-config.ts
@@ -1,4 +1,4 @@
-const os = require('os');
+import os from 'os';
 
 module.exports = {
   listenIp: '0.0.0.0',
@@ -7,7 +7,7 @@ module.exports = {
   sslKey: './ssl-snakeoil.key',
   mediasoup: {
     // Worker settings
-    numWorkers : Object.keys(os.cpus()).length,
+    numWorkers: Object.keys(os.cpus()).length,
     worker: {
       rtcMinPort: 10000,
       rtcMaxPort: 10100,
@@ -28,23 +28,25 @@ module.exports = {
     },
     // Router settings
     router: {
-      codecs: [{
-        kind: 'audio',
-        mimeType: 'audio/opus',
-        clockRate: 48000,
-        channels: 2
-      }]
+      codecs: [
+        {
+          kind: 'audio',
+          mimeType: 'audio/opus',
+          clockRate: 48000,
+          channels: 2,
+        },
+      ],
     },
     // WebRtcTransport settings
     webRtcTransport: {
       listenIps: [
         {
           ip: '0.0.0.0',
-          announcedIp:'127.0.0.1' // replace by public IP address
-        }
+          announcedIp: '127.0.0.1', // replace by public IP address
+        },
       ],
       maxIncomingBitrate: 1500000,
       initialAvailableOutgoingBitrate: 1000000,
-    }
-  }
+    },
+  },
 };
diff --git a/rtc-server/package.json b/rtc-server/package.json
new file mode 100644
index 0000000..8cfede6
--- /dev/null
+++ b/rtc-server/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "rtc-server",
+  "version": "1.0.0",
+  "description": "mediasoup voice server",
+  "main": "server.ts",
+  "scripts": {
+    "dev": "nodemon server.ts",
+    "build": "tsc -p .",
+    "start": "node build/server.js",
+    "lint": "tslint --project tsconfig.json",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^4.17.1",
+    "mediasoup": "^3.7.4",
+    "socket.io": "^2.4.1"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.11",
+    "@types/node": "^15.0.1",
+    "@types/socket.io": "^2.1.13",
+    "nodemon": "^2.0.7",
+    "prettier": "^2.2.1",
+    "ts-node": "^9.1.1",
+    "tslint": "^6.1.3",
+    "tslint-config-airbnb": "^5.11.2",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.2.4"
+  }
+}
diff --git a/rtc-server/server.ts b/rtc-server/server.ts
new file mode 100644
index 0000000..69ddebd
--- /dev/null
+++ b/rtc-server/server.ts
@@ -0,0 +1,15 @@
+import express, { Application } from 'express';
+import http, { Server } from 'http';
+import socketIo, { Server as WebSocketServer } from 'socket.io';
+import attachSocketEvents from './utils/attach-socket-events';
+
+const app: Application = express();
+const server: Server = http.createServer(app);
+const io: WebSocketServer = socketIo(server, { serveClient: false });
+attachSocketEvents(io);
+
+const PORT: string | number = process.env.PORT || 4000;
+server.listen(PORT, () =>
+  // tslint:disable-next-line: no-console
+  console.log(`🔊 Voice Server running on port ${PORT}`)
+);
diff --git a/rtc-server/tsconfig.json b/rtc-server/tsconfig.json
new file mode 100644
index 0000000..e7d4586
--- /dev/null
+++ b/rtc-server/tsconfig.json
@@ -0,0 +1,69 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    "outDir": "./build",                        /* Redirect output structure to the directory. */
+    "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+  }
+}
diff --git a/rtc-server/tslint.json b/rtc-server/tslint.json
new file mode 100644
index 0000000..1a46e34
--- /dev/null
+++ b/rtc-server/tslint.json
@@ -0,0 +1,21 @@
+{
+  "defaultSeverity": "error",
+  "extends": [
+    "tslint:recommended",
+    "tslint-config-prettier",
+    "tslint-config-airbnb"
+  ],
+  "jsRules": {},
+  "rules": {
+    "quotemark": [true, "single"],
+    "trailing-comma": [false],
+    "object-literal-shorthand": true,
+    "object-shorthand-properties-first": false,
+    "no-var-requires": false,
+    "variable-name": false,
+    "max-classes-per-file": false,
+    "no-else-after-return": false,
+    "ter-arrow-parens": false
+  },
+  "rulesDirectory": []
+}
diff --git a/rtc-server/utils/Rooms.ts b/rtc-server/utils/Rooms.ts
new file mode 100644
index 0000000..5145e9a
--- /dev/null
+++ b/rtc-server/utils/Rooms.ts
@@ -0,0 +1,359 @@
+import { types as mediasoupType } from 'mediasoup';
+const mediasoupConfig = require('../mediasoup-config');
+import { Server as WebSocketServer, Socket } from 'socket.io';
+
+interface RtcClient {
+  // the id of session socket. allows 1:1 mapping from voice server to session server
+  redisClientId: string;
+  transports: Map<string, mediasoupType.Transport>;
+  consumers: Map<string, mediasoupType.Consumer>;
+  producers: Map<string, mediasoupType.Producer>;
+  rtpCapabilities: mediasoupType.RtpCapabilities | undefined;
+}
+
+interface Room {
+  clients: RtcClient[];
+  router: mediasoupType.Router;
+  hostId: string;
+}
+
+interface RtcClientRoomMap {
+  [clientId: string]: string;
+}
+
+// Maps RTC socket id to session socket id
+interface RtcClientSessionMap {
+  [rtcSocketId: string]: string;
+}
+
+interface RoomMap {
+  [roomId: string]: Room;
+}
+
+/**
+ * Singleton class that holds all RtcClients in memory
+ */
+class Rooms {
+  private roomMap: RoomMap;
+  private clientRoomMap: RtcClientRoomMap;
+  private rtcSessionMap: RtcClientSessionMap;
+  private audioObserver: mediasoupType.AudioLevelObserver | undefined;
+
+  constructor() {
+    this.roomMap = {};
+    this.clientRoomMap = {};
+    this.rtcSessionMap = {};
+    this.audioObserver = undefined;
+  }
+
+  getRoom(roomId: string): Room {
+    return this.roomMap[roomId];
+  }
+
+  getRoomClients(roomId: string): RtcClient[] {
+    if (this.roomMap[roomId]) {
+      return this.roomMap[roomId].clients;
+    }
+    throw new Error('Room with this ID does not exist');
+  }
+
+  getClientRoomId(clientId: string): string {
+    if (this.clientRoomMap[clientId]) {
+      return this.clientRoomMap[clientId];
+    }
+    throw new Error('This client ID does not exist');
+  }
+
+  getClient(clientId: string): RtcClient {
+    const roomId: string = this.getClientRoomId(clientId);
+    const clientList: RtcClient[] = this.getRoomClients(roomId);
+    const lookup: RtcClient | undefined = clientList.find(
+      (client: RtcClient) => client.redisClientId === clientId
+    );
+    if (!lookup) {
+      throw new Error('No clients with this ID exist in any rooms');
+    } else {
+      return lookup;
+    }
+  }
+
+  getRtpCapabilities(roomId: string): mediasoupType.RtpCapabilities {
+    return this.roomMap[roomId].router.rtpCapabilities;
+  }
+
+  getRedisClientId(rtcSocketId: string) {
+    return this.rtcSessionMap[rtcSocketId];
+  }
+
+  async addRoom(roomId: string, worker: mediasoupType.Worker) {
+    if (!this.roomMap[roomId]) {
+      const mediaCodecs = mediasoupConfig.mediasoup.router.codecs;
+      const router = await worker.createRouter({ mediaCodecs });
+      this.audioObserver = await router.createAudioLevelObserver({
+        maxEntries: 100,
+        threshold: -90,
+        interval: 500,
+      });
+      const roomDetails = {
+        clients: [],
+        router,
+        hostId: roomId,
+      };
+      this.roomMap[roomId] = roomDetails;
+    }
+  }
+
+  addClient(roomId: string, rtcSocketId: string, redisClientId: string) {
+    if (this.clientRoomMap[redisClientId]) {
+      return;
+    }
+    if (this.roomMap[roomId]) {
+      const newClient: RtcClient = {
+        redisClientId,
+        transports: new Map(),
+        consumers: new Map(),
+        producers: new Map(),
+        rtpCapabilities: undefined,
+      };
+
+      this.roomMap[roomId].clients.push(newClient);
+      this.clientRoomMap[redisClientId] = roomId;
+      this.rtcSessionMap[rtcSocketId] = redisClientId;
+
+      const room = this.getRoom(roomId);
+      if (!room.hostId) room.hostId = redisClientId;
+    } else {
+      throw new Error('Room with this ID does not exist');
+    }
+  }
+
+  async createTransport(clientId: string, roomId: string) {
+    const {
+      maxIncomingBitrate,
+      initialAvailableOutgoingBitrate,
+      listenIps,
+    } = mediasoupConfig.mediasoup.webRtcTransport;
+    const router = this.roomMap[roomId].router;
+
+    const transport = await router.createWebRtcTransport({
+      listenIps,
+      enableUdp: true,
+      enableTcp: true,
+      preferUdp: true,
+      initialAvailableOutgoingBitrate,
+    });
+
+    if (maxIncomingBitrate) {
+      await transport.setMaxIncomingBitrate(maxIncomingBitrate);
+    }
+
+    transport.on('dtlsstatechange', (dtlsState) => {
+      if (dtlsState === 'closed') transport.close();
+    });
+
+    this.getClient(clientId).transports.set(transport.id, transport);
+    return {
+      id: transport.id,
+      iceParams: transport.iceParameters,
+      iceCandidates: transport.iceCandidates,
+      dtlsParameters: transport.dtlsParameters,
+    };
+  }
+
+  async addTransport(
+    client: RtcClient,
+    transportId: string,
+    dtlsParameters: mediasoupType.DtlsParameters
+  ) {
+    if (!client.transports.has(transportId)) return;
+    await client.transports.get(transportId)?.connect({
+      dtlsParameters,
+    });
+  }
+
+  async addProducer(
+    producerTransportId: string,
+    rtpParameters: mediasoupType.RtpParameters,
+    mediaType: mediasoupType.MediaKind,
+    client: RtcClient
+  ) {
+    return new Promise(async (resolve) => {
+      const producer = await this.createProducer(
+        client,
+        producerTransportId,
+        rtpParameters,
+        mediaType
+      );
+      resolve(producer.id);
+    });
+  }
+
+  async createProducer(
+    client: RtcClient,
+    producerTransportId: string,
+    rtpParameters: mediasoupType.RtpParameters,
+    mediaType: mediasoupType.MediaKind
+  ) {
+    const producer = await client.transports.get(producerTransportId)?.produce({
+      kind: mediaType,
+      rtpParameters,
+      appData: { clientId: client.redisClientId }, // Used for telling if the user is talking
+    });
+
+    if (producer === undefined) throw new Error('Producer is undefined');
+
+    client.producers.set(producer.id, producer);
+
+    producer.on('closeTransport', () => {
+      if (producer !== undefined) {
+        producer.close();
+        client.producers.delete(producer.id);
+      }
+    });
+
+    return producer;
+  }
+
+  async addConsumer(
+    io: WebSocketServer,
+    socket: Socket,
+    client: RtcClient,
+    consumerTransportId: string,
+    producerId: string,
+    rtpCapabilities: mediasoupType.RtpCapabilities
+  ) {
+    const roomId = this.getClientRoomId(client.redisClientId);
+    const room = this.getRoom(roomId);
+
+    if (!room.router.canConsume({ producerId, rtpCapabilities })) {
+      throw new Error(`Router can\'t consume ${producerId}`);
+    }
+
+    const consumer:
+      | mediasoupType.Consumer
+      | undefined = await this.createConsumer(
+      client,
+      consumerTransportId,
+      producerId,
+      rtpCapabilities
+    );
+
+    if (this.audioObserver === undefined) {
+      throw new Error('Audio observer is undefined');
+    }
+    this.audioObserver.addProducer({ producerId });
+    this.setAudioObserverEvents(room, io, roomId);
+
+    if (consumer === undefined) throw new Error('Consumer is undefined');
+    consumer.on('transportclose', () => {
+      if (consumer === undefined) throw new Error('Consumer is undefined');
+      client.consumers.delete(consumer.id);
+    });
+
+    consumer.on('producerClosed', () => {
+      if (consumer === undefined) throw new Error('Consumer is undefined');
+      client.consumers.delete(consumer.id);
+      io.to(socket.id).emit('consumerClosed', { consumerId: consumer.id });
+    });
+
+    client.consumers.set(consumer.id, consumer);
+
+    return {
+      consumer,
+      consumerParams: {
+        producerId,
+        consumerId: consumer.id,
+        mediaKind: consumer.kind,
+        rtpParameters: consumer.rtpParameters,
+        consumerType: consumer.type,
+        producerPaused: consumer.producerPaused,
+      },
+    };
+  }
+
+  async createConsumer(
+    client: RtcClient,
+    consumerTransportId: string,
+    producerId: string,
+    rtpCapabilities: mediasoupType.RtpCapabilities
+  ) {
+    const consumerTransport = client.transports.get(consumerTransportId);
+    const consumer = await consumerTransport?.consume({
+      producerId,
+      rtpCapabilities,
+      paused: false,
+    });
+
+    if (consumer?.type === 'simulcast') {
+      await consumer.setPreferredLayers({
+        spatialLayer: 2,
+        temporalLayer: 2,
+      });
+    }
+
+    return consumer;
+  }
+
+  setAudioObserverEvents(room: Room, io: WebSocketServer, roomId: string) {
+    this.audioObserver?.on('volumes', (volumes) => {
+      const clientVolumes: { [clientId: string]: number } = {};
+      const clients: string[] = [];
+      for (const volume of volumes) {
+        clientVolumes[volume.producer.appData.clientId] = volume.volume;
+      }
+      room.clients.forEach((client) => clients.push(client.redisClientId));
+      io.to(roomId).emit('activeSpeaker', {
+        clientVolumes,
+        clients,
+      });
+    });
+
+    this.audioObserver?.on('silence', () => {
+      io.to(roomId).emit('activeSpeaker', {
+        clientVolumes: null,
+      });
+    });
+  }
+
+  closeTransports(client: RtcClient) {
+    client.transports.forEach((transport) => transport.close());
+  }
+
+  closeProducer(clientId: string, producerId: string) {
+    const client = this.getClient(clientId);
+
+    if (client.producers.get(producerId) === undefined) {
+      throw new Error(`Producer id ${producerId} can\'t be found`);
+    }
+    client.producers.get(producerId)?.close();
+    client.producers.delete(producerId);
+  }
+
+  removeClient(roomId: string, rtcSocketId: string, redisClientId: string) {
+    if (!this.clientRoomMap[redisClientId]) {
+      return;
+    }
+    if (this.roomMap[roomId]) {
+      const clientList: RtcClient[] = this.getRoomClients(roomId);
+      for (let i = 0; i < clientList.length; i += 1) {
+        const client = clientList[i];
+        if (client.redisClientId === redisClientId) {
+          clientList.splice(i, 1);
+          delete this.clientRoomMap[redisClientId];
+          delete this.rtcSessionMap[rtcSocketId];
+          return clientList;
+        }
+      }
+    } else {
+      throw new Error('Room with this ID does not exist');
+    }
+  }
+
+  closeRoom(roomId: string) {
+    const room = this.getRoom(roomId);
+    room.router.close();
+    delete this.roomMap[roomId];
+  }
+}
+
+export default new Rooms();
diff --git a/rtc-server/utils/attach-socket-events.ts b/rtc-server/utils/attach-socket-events.ts
new file mode 100644
index 0000000..7ef2179
--- /dev/null
+++ b/rtc-server/utils/attach-socket-events.ts
@@ -0,0 +1,177 @@
+import { Server as WebSocketServer, Socket } from 'socket.io';
+import { types as mediasoupType } from 'mediasoup';
+import Rooms from './Rooms';
+
+const mediasoup = require('mediasoup');
+const mediasoupConfig = require('../mediasoup-config');
+
+/**
+ * Attaches event listeners to socket instance
+ */
+async function attachSocketEvents(io: WebSocketServer) {
+  const workers: mediasoupType.Worker[] = [];
+  let workerIndex = 0;
+  await createMediasoupWorkers(workers);
+
+  io.on('connection', (socket: Socket) => {
+    // tslint:disable-next-line: no-console
+    console.log(`\nNew socket established: ${socket.id}`);
+
+    socket.on('join', async (clientData) => {
+      // tslint:disable-next-line: no-console
+      console.log('join broadcast triggered');
+
+      const { roomId, redisClientId } = clientData;
+
+      socket.join(roomId);
+
+      const worker = getMediasoupWorker(workerIndex, workers);
+      if (workerIndex + 1 === workers.length) workerIndex = 0;
+
+      await Rooms.addRoom(roomId, worker);
+      Rooms.addClient(roomId, socket.id, redisClientId);
+    });
+
+    socket.on('getRtpCapabilities', (data, callback) => {
+      const redisClientId = Rooms.getRedisClientId(socket.id);
+      const roomId = Rooms.getClientRoomId(redisClientId);
+      callback(Rooms.getRtpCapabilities(roomId));
+    });
+
+    socket.on('getProducers', () => {
+      const redisClientId = Rooms.getRedisClientId(socket.id);
+      const roomId = Rooms.getClientRoomId(redisClientId);
+      const roomClients = Rooms.getRoomClients(roomId);
+
+      const producerIds: { producerId: string }[] = [];
+      roomClients.forEach((client) => {
+        if (client.redisClientId !== redisClientId) {
+          for (const [producerId, producer] of client.producers) {
+            producerIds.push({ producerId: producer.id });
+          }
+        }
+      });
+
+      socket.emit('newProducers', producerIds);
+    });
+
+    socket.on('createTransport', async (data, callback) => {
+      const redisClientId = Rooms.getRedisClientId(socket.id);
+      const roomId = Rooms.getClientRoomId(redisClientId);
+      callback(await Rooms.createTransport(redisClientId, roomId));
+    });
+
+    socket.on(
+      'connectTransport',
+      async ({ transportId, dtlsParameters }, callback) => {
+        const redisClientId = Rooms.getRedisClientId(socket.id);
+        const client = Rooms.getClient(redisClientId);
+        await Rooms.addTransport(client, transportId, dtlsParameters);
+        callback('success');
+      }
+    );
+
+    socket.on(
+      'produce',
+      async ({ producerTransportId, mediaType, rtpParameters }, callback) => {
+        const redisClientId = Rooms.getRedisClientId(socket.id);
+        const client = Rooms.getClient(redisClientId);
+        const roomId = Rooms.getClientRoomId(redisClientId);
+
+        // Create client's producer
+        const producerId = await Rooms.addProducer(
+          producerTransportId,
+          rtpParameters,
+          mediaType,
+          client
+        );
+
+        io.to(roomId).emit('newProducers', [{ producerId }]);
+        callback({ producerId });
+      }
+    );
+
+    socket.on(
+      'consume',
+      async (
+        { consumerTransportId, producerId, rtpCapabilities },
+        callback
+      ) => {
+        const redisClientId = Rooms.getRedisClientId(socket.id);
+        const client = Rooms.getClient(redisClientId);
+        const consumerResult = await Rooms.addConsumer(
+          io,
+          socket,
+          client,
+          consumerTransportId,
+          producerId,
+          rtpCapabilities
+        );
+
+        if (consumerResult === undefined) {
+          throw new Error('Unable to create consumer');
+        }
+        const { consumerParams } = consumerResult;
+        callback(consumerParams);
+      }
+    );
+
+    socket.on('producerClosed', ({ producerId }) => {
+      const redisClientId = Rooms.getRedisClientId(socket.id);
+      Rooms.closeProducer(redisClientId, producerId);
+    });
+
+    socket.on('disconnect', () => {
+      const redisClientId = Rooms.getRedisClientId(socket.id);
+      const client = Rooms.getClient(redisClientId);
+      const roomId = Rooms.getClientRoomId(redisClientId);
+      const room = Rooms.getRoom(roomId);
+
+      // Choose the next host if the socket that's disconnecting is the host
+      if (redisClientId === room.hostId) {
+        if (room.clients.length - 1 !== 0) {
+          room.hostId = room.clients[1].redisClientId;
+        } else {
+          return Rooms.closeRoom(roomId);
+        }
+      }
+      Rooms.closeTransports(client);
+      Rooms.removeClient(roomId, socket.id, redisClientId);
+    });
+  });
+}
+
+const createMediasoupWorkers = async (workers: mediasoupType.Worker[]) => {
+  const {
+    numWorkers,
+    logLevel,
+    logTags,
+    rtcMinPort,
+    rtcMaxPort,
+  } = mediasoupConfig.mediasoup;
+
+  for (let i = 0; i < numWorkers; i += 1) {
+    const worker = await mediasoup.createWorker({
+      logLevel,
+      logTags,
+      rtcMinPort,
+      rtcMaxPort,
+    });
+
+    worker.on('died', () => {
+      throw new Error('worker died');
+    });
+
+    workers.push(worker);
+  }
+};
+
+const getMediasoupWorker = (
+  workerIndex: number,
+  workers: mediasoupType.Worker[]
+) => {
+  const worker = workers[workerIndex];
+  return worker;
+};
+
+export default attachSocketEvents;
diff --git a/server/package.json b/server/package.json
index f0aaf49..8c22028 100644
--- a/server/package.json
+++ b/server/package.json
@@ -16,7 +16,6 @@
   "dependencies": {
     "express": "^4.17.1",
     "linked-list": "^2.1.0",
-    "mediasoup": "^3.7.0",
     "socket.io": "^2.4.1"
   },
   "devDependencies": {
diff --git a/server/server.ts b/server/server.ts
index 1d7361a..92e8dac 100644
--- a/server/server.ts
+++ b/server/server.ts
@@ -1,13 +1,15 @@
 import express, { Application } from 'express';
 import http, { Server } from 'http';
 import socketIo, { Server as WebSocketServer } from 'socket.io';
-import socketHandler from './utils/socket-handler';
+import attachSocketEvents from './utils/attach-socket-events';
 
 const app: Application = express();
 const server: Server = http.createServer(app);
 const io: WebSocketServer = socketIo(server, { serveClient: false });
-socketHandler(io);
+attachSocketEvents(io);
 
 const PORT: string | number = process.env.PORT || 5000;
-// tslint:disable-next-line: no-console
-server.listen(PORT, () => console.log(`🚀 Server running on port ${PORT}`));
+server.listen(PORT, () =>
+  // tslint:disable-next-line: no-console
+  console.log(`🚀 Session Server running on port ${PORT}`)
+);
diff --git a/server/utils/Rooms.ts b/server/utils/Rooms.ts
index b712dae..875e99b 100644
--- a/server/utils/Rooms.ts
+++ b/server/utils/Rooms.ts
@@ -1,7 +1,4 @@
 import { Playlist } from './Playlist';
-import { types as mediasoupType } from 'mediasoup';
-const mediasoupConfig = require('../mediasoup-config');
-import { Server as WebSocketServer, Socket } from 'socket.io';
 
 export interface ClientMap {
   [clientId: string]: string;
@@ -11,20 +8,15 @@ export interface Client {
   id: string;
   name: string;
   isMuted: boolean;
-  transports: Map<string, mediasoupType.Transport>;
-  consumers: Map<string, mediasoupType.Consumer>;
-  producers: Map<string, mediasoupType.Producer>;
-  rtpCapabilities: mediasoupType.RtpCapabilities | undefined;
 }
 
 export interface Room {
   clients: Client[];
   youtubeID: string;
   playlist: Playlist;
-  router: mediasoupType.Router;
   roomType: string;
   hostId: string;
-  waitingClients: {[socketId: string]: string};
+  waitingClients: { [socketId: string]: string };
 }
 
 export interface RoomMap {
@@ -37,40 +29,28 @@ export interface RoomMap {
 class Rooms {
   private roomMap: RoomMap;
   private clientMap: ClientMap; // maps any socket.id to its respective roomId
-  private audioObserver: mediasoupType.AudioLevelObserver | undefined;
   // used in disconnect to find if a user is in a waiting room of a room
-  private waitingList: {[socketId: string]: string};
+  private waitingList: { [socketId: string]: string };
 
   constructor() {
     this.roomMap = {};
     this.clientMap = {};
-    this.audioObserver = undefined;
     this.waitingList = {}; // socketid -> roomId
   }
 
   closeRoom(roomId: string) {
-    const room = this.getRoom(roomId);
-    room.router.close();
     delete this.roomMap[roomId];
   }
 
-  async addRoom(roomId: string, youtubeID: string, worker: mediasoupType.Worker, roomType: string) {
+  addRoom(roomId: string, youtubeID: string, roomType: string) {
     if (!this.roomMap[roomId]) {
-      const mediaCodecs = mediasoupConfig.mediasoup.router.codecs;
-      const router = await worker.createRouter({ mediaCodecs });
-      this.audioObserver = await router.createAudioLevelObserver({
-        maxEntries: 100,
-        threshold: -90,
-        interval: 500
-      });
       const roomDetails = {
         clients: [],
         youtubeID,
         playlist: new Playlist(),
-        router,
         roomType,
         hostId: roomId,
-        waitingClients: {} // socketId -> name
+        waitingClients: {}, // socketId -> name
       };
       this.roomMap[roomId] = roomDetails;
     }
@@ -92,10 +72,6 @@ class Rooms {
         id: clientId,
         name: clientName,
         isMuted: false,
-        transports: new Map(),
-        consumers: new Map(),
-        producers: new Map(),
-        rtpCapabilities: undefined
       };
       this.roomMap[roomId].clients.push(newClient);
       this.clientMap[clientId] = roomId;
@@ -215,206 +191,6 @@ class Rooms {
   getPlaylistVideoIds(roomId: string): string[] {
     return this.roomMap[roomId].playlist.getPlaylistIds();
   }
-
-  getRtpCapabilities(roomId: string): mediasoupType.RtpCapabilities {
-    return this.roomMap[roomId].router.rtpCapabilities;
-  }
-
-  async createTransport(clientId: string, roomId: string) {
-    const {
-      maxIncomingBitrate,
-      initialAvailableOutgoingBitrate,
-      listenIps
-    } = mediasoupConfig.mediasoup.webRtcTransport;
-    const router = this.roomMap[roomId].router;
-
-    const transport = await router.createWebRtcTransport({
-      listenIps,
-      enableUdp: true,
-      enableTcp: true,
-      preferUdp: true,
-      initialAvailableOutgoingBitrate
-    });
-
-    if (maxIncomingBitrate) {
-      await transport.setMaxIncomingBitrate(maxIncomingBitrate);
-    }
-
-    transport.on('dtlsstatechange', (dtlsState) => {
-      if (dtlsState === 'closed') transport.close();
-    });
-
-    this.getClient(clientId).transports.set(transport.id, transport);
-    return {
-      id: transport.id,
-      iceParams: transport.iceParameters,
-      iceCandidates: transport.iceCandidates,
-      dtlsParameters: transport.dtlsParameters
-    };
-  }
-
-  async addTransport(
-    client: Client,
-    transportId: string,
-    dtlsParameters: mediasoupType.DtlsParameters
-  ) {
-    if (!client.transports.has(transportId)) return;
-    await client.transports.get(transportId)?.connect({
-      dtlsParameters
-    });
-  }
-
-  async addProducer(
-    producerTransportId: string,
-    rtpParameters: mediasoupType.RtpParameters,
-    mediaType: mediasoupType.MediaKind,
-    client: Client
-  ) {
-    return new Promise(async (resolve) => {
-      const producer = await this.createProducer(
-        client,
-        producerTransportId,
-        rtpParameters,
-        mediaType
-      );
-      resolve(producer.id);
-    });
-  }
-
-  async createProducer(
-    client: Client,
-    producerTransportId: string,
-    rtpParameters: mediasoupType.RtpParameters,
-    mediaType: mediasoupType.MediaKind
-  ) {
-    const producer = await client.transports.get(producerTransportId)?.produce({
-      kind: mediaType,
-      rtpParameters,
-      appData: { clientId: client.id } // Used for telling if the user is talking
-    });
-
-    if (producer === undefined) throw new Error('Producer is undefined');
-
-    client.producers.set(producer.id, producer);
-
-    producer.on('closeTransport', () => {
-      if (producer !== undefined) {
-        producer.close();
-        client.producers.delete(producer.id);
-      }
-    });
-
-    return producer;
-  }
-
-  async addConsumer(
-    io: WebSocketServer,
-    socket: Socket,
-    client: Client,
-    consumerTransportId: string,
-    producerId: string,
-    rtpCapabilities: mediasoupType.RtpCapabilities
-  ) {
-    const roomId = this.getClientRoomId(client.id);
-    const room = this.getRoom(roomId);
-
-    if (!room.router.canConsume({ producerId, rtpCapabilities })) {
-      throw new Error(`Router can\'t consume ${producerId}`);
-    }
-
-    const consumer: mediasoupType.Consumer | undefined = await this.createConsumer(
-      client,
-      consumerTransportId,
-      producerId,
-      rtpCapabilities
-    );
-
-    if (this.audioObserver === undefined) throw new Error('Audio observer is undefined');
-    this.audioObserver.addProducer({ producerId });
-    this.setAudioObserverEvents(room, io, roomId);
-
-    if (consumer === undefined) throw new Error('Consumer is undefined');
-    consumer.on('transportclose', () => {
-      if (consumer === undefined) throw new Error('Consumer is undefined');
-      client.consumers.delete(consumer.id);
-    });
-
-    consumer.on('producerClosed', () => {
-      if (consumer === undefined) throw new Error('Consumer is undefined');
-      client.consumers.delete(consumer.id);
-      io.to(socket.id).emit('consumerClosed', { consumerId: consumer.id });
-    });
-
-    client.consumers.set(consumer.id, consumer);
-
-    return {
-      consumer,
-      consumerParams: {
-        producerId,
-        consumerId: consumer.id,
-        mediaKind: consumer.kind,
-        rtpParameters: consumer.rtpParameters,
-        consumerType: consumer.type,
-        producerPaused: consumer.producerPaused
-      }
-    };
-  }
-
-  async createConsumer(
-    client: Client,
-    consumerTransportId: string,
-    producerId: string,
-    rtpCapabilities: mediasoupType.RtpCapabilities
-  ) {
-    const consumerTransport = client.transports.get(consumerTransportId);
-    const consumer = await consumerTransport?.consume({
-      producerId,
-      rtpCapabilities,
-      paused: false
-    });
-
-    if (consumer?.type === 'simulcast') {
-      await consumer.setPreferredLayers({
-        spatialLayer: 2,
-        temporalLayer: 2
-      });
-    }
-
-    return consumer;
-  }
-
-  setAudioObserverEvents(room: Room, io: WebSocketServer, roomId: string) {
-    this.audioObserver?.on('volumes', (volumes) => {
-      const clientVolumes: {[clientId: string]: number} = {};
-      for (const volume of volumes) {
-        clientVolumes[volume.producer.appData.clientId] = volume.volume;
-      }
-      io.to(roomId).emit('activeSpeaker', {
-        clientVolumes,
-        clients: room.clients
-      });
-    });
-
-    this.audioObserver?.on('silence', () => {
-      io.to(roomId).emit('activeSpeaker', {
-        clientVolumes: null
-      });
-    });
-  }
-
-  closeTransports(client: Client) {
-    client.transports.forEach(transport => transport.close());
-  }
-
-  closeProducer(clientId: string, producerId: string) {
-    const client = this.getClient(clientId);
-
-    if (client.producers.get(producerId) === undefined) {
-      throw new Error(`Producer id ${producerId} can\'t be found`);
-    }
-    client.producers.get(producerId)?.close();
-    client.producers.delete(producerId);
-  }
 }
 
 export default new Rooms();
diff --git a/server/utils/socket-handler.ts b/server/utils/attach-socket-events.ts
similarity index 57%
rename from server/utils/socket-handler.ts
rename to server/utils/attach-socket-events.ts
index 5df8dff..0db0126 100644
--- a/server/utils/socket-handler.ts
+++ b/server/utils/attach-socket-events.ts
@@ -7,17 +7,11 @@ import {
   deletePlaylistItem,
   movePlaylistItem,
 } from './socket-notifier';
-import { types as mediasoupType } from 'mediasoup';
 
-const mediasoup = require('mediasoup');
-const mediasoupConfig = require('../mediasoup-config');
-
-const socketHandler = async (io: WebSocketServer) => {
-  const workers: mediasoupType.Worker[] = [];
-  let workerIndex = 0;
-  await createMediasoupWorkers(workers);
-
-  // Client connection event
+/**
+ * Attaches event listeners to socket instance
+ */
+async function attachSocketEvents(io: WebSocketServer) {
   io.on('connection', (socket: Socket) => {
     // tslint:disable-next-line: no-console
     console.log(`\nNew socket established: ${socket.id}`);
@@ -26,14 +20,18 @@ const socketHandler = async (io: WebSocketServer) => {
     socket.on('join', async (clientData) => {
       // tslint:disable-next-line: no-console
       console.log('join broadcast triggered');
-      const { roomId, clientId, clientName, youtubeID, roomType, canJoin } = clientData;
+      const {
+        roomId,
+        clientId,
+        clientName,
+        youtubeID,
+        roomType,
+        canJoin,
+      } = clientData;
       if (canJoin) {
         socket.join(roomId);
 
-        const worker = getMediasoupWorker(workerIndex, workers);
-        if (workerIndex + 1 === workers.length) workerIndex = 0;
-
-        await Rooms.addRoom(roomId, youtubeID, worker, roomType);
+        Rooms.addRoom(roomId, youtubeID, roomType);
         Rooms.addClient(roomId, clientId, clientName);
 
         // TODO: not sure if this is listened to on client side
@@ -53,7 +51,6 @@ const socketHandler = async (io: WebSocketServer) => {
           createUserMessage(null, clientId, `${clientName} entered`)
         );
 
-        // TODO: refactor logic without youtubeID in general
         if (!youtubeID) {
           socket.emit(
             'notifyClient',
@@ -67,97 +64,15 @@ const socketHandler = async (io: WebSocketServer) => {
       }
     });
 
-    // -------------------------- MEDIASOUP EVENTS --------------------------
-    socket.on('getRtpCapabilities', (data, callback) => {
-      const client = Rooms.getClient(socket.id);
-      const roomId = Rooms.getClientRoomId(client.id);
-      callback(Rooms.getRtpCapabilities(roomId));
-    });
-
-    socket.on('getProducers', () => {
-      const roomId = Rooms.getClientRoomId(socket.id);
-      const roomClients = Rooms.getRoomClients(roomId);
-
-      const producerIds: { producerId: string }[] = [];
-      roomClients.forEach((client) => {
-        if (client.id !== socket.id) {
-          for (const [producerId, producer] of client.producers) {
-            producerIds.push({ producerId: producer.id });
-          }
-        }
-      });
-
-      socket.emit('newProducers', producerIds);
-    });
-
-    socket.on('createTransport', async (data, callback) => {
-      const client = Rooms.getClient(socket.id);
-      const roomId = Rooms.getClientRoomId(client.id);
-      callback(await Rooms.createTransport(socket.id, roomId));
-    });
-
-    socket.on('connectTransport', async({
-      transportId,
-      dtlsParameters
-    },                                  callback) => {
-      const client = Rooms.getClient(socket.id);
-      await Rooms.addTransport(client, transportId, dtlsParameters);
-      callback('success');
-    });
-
-    socket.on('produce', async ({
-      producerTransportId,
-      mediaType,
-      rtpParameters
-    },                          callback) => {
-      const client = Rooms.getClient(socket.id);
-      const roomId = Rooms.getClientRoomId(client.id);
-
-      // Create client's producer
-      const producerId = await Rooms.addProducer(
-        producerTransportId,
-        rtpParameters,
-        mediaType,
-        client
-      );
-
-      io.to(roomId).emit('newProducers', [{ producerId }]);
-      callback({ producerId });
-    });
-
-    socket.on('consume', async ({
-      consumerTransportId,
-      producerId,
-      rtpCapabilities,
-    },                          callback) => {
-      const client = Rooms.getClient(socket.id);
-      const consumerResult = await Rooms.addConsumer(
-        io,
-        socket,
-        client,
-        consumerTransportId,
-        producerId,
-        rtpCapabilities
-      );
-
-      if (consumerResult === undefined) throw new Error('Unable to create consumer');
-      const { consumerParams } = consumerResult;
-      callback(consumerParams);
-    });
-
-    socket.on('producerClosed', ({ producerId }) => {
-      Rooms.closeProducer(socket.id, producerId);
-    });
-
     // -------------------------- YOUTUBE EVENTS --------------------------
     socket.on('videoStateChange', (data) => {
       const client = Rooms.getClient(socket.id);
       let message = `${client.name} `;
       switch (data.type) {
-        case('PLAY_VIDEO'):
+        case 'PLAY_VIDEO':
           message += 'started the video';
           break;
-        case('PAUSE_VIDEO'):
+        case 'PAUSE_VIDEO':
           message += 'paused the video';
           break;
       }
@@ -246,7 +161,9 @@ const socketHandler = async (io: WebSocketServer) => {
     socket.on('insertVideoAtIndex', ({ oldIndex, newIndex }) => {
       const client = Rooms.getClient(socket.id);
       const roomId = Rooms.getClientRoomId(client.id);
-      const message = `${client.name} swapped playlist item #${oldIndex + 1} with item #${newIndex + 1}`;
+      const message = `${client.name} swapped playlist item #${
+        oldIndex + 1
+      } with item #${newIndex + 1}`;
 
       Rooms.moveVideo(roomId, oldIndex, newIndex);
       const newPlaylist: string[] = Rooms.getPlaylistVideoIds(roomId);
@@ -259,33 +176,38 @@ const socketHandler = async (io: WebSocketServer) => {
     });
 
     // -------------------------- WAITING ROOM EVENTS --------------------------
-    socket.on('getRoomType', async (
-      { clientName, roomId }: { clientName: string, roomId: string },
-      callback
-    ) => {
-      const room = Rooms.getRoom(roomId);
-      const roomType = room.roomType;
-      if (roomType === 'private') {
-        // Update waiting clients and list in the room
-        room.waitingClients = {
-          ...room.waitingClients,
-          [socket.id]: clientName
-        };
-        Rooms.addToWaitingList(socket.id, roomId);
-
-        // Update waiting clients on the client side of the host
-        io.to(room.hostId).emit('waitingClient', { socketId: socket.id, clientName });
+    socket.on(
+      'getRoomType',
+      async (
+        { clientName, roomId }: { clientName: string; roomId: string },
+        admitClient: () => Promise<void>
+      ) => {
+        const room = Rooms.getRoom(roomId);
+        const roomType = room.roomType;
+        if (roomType === 'private') {
+          // Update waiting clients and list in the room
+          room.waitingClients = {
+            ...room.waitingClients,
+            [socket.id]: clientName,
+          };
+          Rooms.addToWaitingList(socket.id, roomId);
+
+          io.to(room.hostId).emit('waitingClient', {
+            waitingClients: room.waitingClients,
+          });
+        } else {
+          await admitClient();
+        }
       }
+    );
 
-      await callback(roomType);
-    });
-
-    socket.on('waitingResponse', (
-      { socketId, status }: { socketId: string, status: string }
-    ) => {
-      Rooms.removeFromWaiting(socketId);
-      io.to(socketId).emit(status);
-    });
+    socket.on(
+      'waitingResponse',
+      ({ socketId, status }: { socketId: string; status: string }) => {
+        if (status === 'accept') Rooms.removeFromWaiting(socketId);
+        io.to(socketId).emit(status);
+      }
+    );
 
     // -------------------------- OTHER EVENTS --------------------------
     socket.on('mute', ({ id }) => {
@@ -293,7 +215,7 @@ const socketHandler = async (io: WebSocketServer) => {
       const roomId = Rooms.getClientRoomId(client.id);
       const newClients = Rooms.updateMute(id, roomId);
       let message = `${client.name} `;
-      client.isMuted ? message += 'muted' : message += 'unmuted';
+      client.isMuted ? (message += 'muted') : (message += 'unmuted');
 
       io.to(roomId).emit('updateClientList', newClients);
       io.to(Rooms.getClientRoomId(client.id)).emit(
@@ -313,17 +235,18 @@ const socketHandler = async (io: WebSocketServer) => {
         if (socket.id === room.hostId) {
           if (room.clients.length - 1 !== 0) {
             room.hostId = room.clients[1].id;
-            socket.to(roomId).emit('newHost', room.clients[1].name, room.hostId);
+            socket
+              .to(roomId)
+              .emit('newHost', room.clients[1].name, room.hostId);
             io.to(room.hostId).emit('updateWaitingClients', {
               waitingClientList: room.waitingClients,
-              clientIdLeft: ''
+              clientIdLeft: '',
             });
           } else {
             Rooms.closeRoom(roomId);
             return;
           }
         }
-        Rooms.closeTransports(client);
         const newClientList = Rooms.removeClient(roomId, socket.id);
         const message = `${client.name} left`;
         io.to(roomId).emit('updateClientList', newClientList);
@@ -338,41 +261,11 @@ const socketHandler = async (io: WebSocketServer) => {
 
         io.to(room.hostId).emit('updateWaitingClients', {
           waitingClientList: room.waitingClients,
-          clientIdLeft: socket.id
+          clientIdLeft: socket.id,
         });
       }
     });
   });
-};
-
-const createMediasoupWorkers = async (workers: mediasoupType.Worker[]) => {
-  const {
-    numWorkers,
-    logLevel,
-    logTags,
-    rtcMinPort,
-    rtcMaxPort
-  } = mediasoupConfig.mediasoup;
-
-  for (let i = 0; i < numWorkers; i += 1) {
-    const worker = await mediasoup.createWorker({
-      logLevel,
-      logTags,
-      rtcMinPort,
-      rtcMaxPort
-    });
-
-    worker.on('died', () => {
-      throw new Error('worker died');
-    });
-
-    workers.push(worker);
-  }
-};
-
-const getMediasoupWorker = (workerIndex: number, workers: mediasoupType.Worker[]) => {
-  const worker = workers[workerIndex];
-  return worker;
-};
+}
 
-export default socketHandler;
+export default attachSocketEvents;