Personal2020
LobbyBot 2.0, Fortnite bots
Complete Fortnite bot system with multi-account management, central Discord bot, real-time web dashboard and community of 8,500+ members. Project started during COVID at age 16, became my biggest personal project.
- Duration
- Ongoing personal project, since 2020
- Team
- Individual project, community of 8,500+ Discord members
- My role
- Sole Developer: design, development, maintenance and community management
Context
LobbyBot 2.0 is my biggest personal project. It started in 2020, during COVID, when I was 16 years old. Originally, it was simply Python Fortnite bots that allowed players to see all the game's skins and dances. The project was funded through my Epic Games creator code advertising (10% commission on each purchase made by my supporters on the Epic Games store).
Players used the bots to preview upcoming skins and dances in the shop, but also to play with them to ease their progression and avoid facing overly strong opponents. I had multiple contacts with Epic Games who authorized me to create these bots.
This small project started during lockdown became, and still remains today, my biggest personal project. The community has over 8,500 members on Discord actively following the project. Over the years, I significantly improved the code: from simple Python scripts to a complete architecture with a central Discord bot in Node.js, a real-time web dashboard, a PostgreSQL database, all orchestrated with Docker.
Major improvements include: automated creation of new bots when a bot reaches its friend limit, automated bot restart in case of crash or server reboot, and an intelligent load balancing system that automatically selects the least loaded bot for each new friend.
Objectives
- 01Multi-bot system: Manage unlimited simultaneous Fortnite bots with intelligent load balancing (900 friends threshold per bot)
- 02Central Discord bot: Allow the 8,500+ community members to interact with Fortnite bots via Discord commands (/add, /login, /list, /shop, /locker...)
- 03Real-time web dashboard: Control interface to view bot status, friends, and manage them (kick, promote, privacy) via Socket.IO
- 04Full automation: Automatic bot creation, restart on crash, and autonomous friend list management
- 05Internationalization: Multilingual support (FR/EN/ES/DE) for the international community
Technical approach
The project evolved from a simple Python script to a complete distributed architecture:
- Phase 1 (2020): Simple Python bots using Epic Games' undocumented APIs, with OAuth2 authentication and basic friend/skin management.
- Phase 2 (evolution): Migration to Node.js architecture for the central Discord bot, using Discord.js to handle community commands.
- Phase 3 (current, LobbyBot 2.0): Complete architecture with three main components orchestrated by Docker:
1. Discord Manager (Node.js): The system's core. Manages all bots simultaneously, load balancing, Discord commands, and PostgreSQL database communication.
2. Web Dashboard (Node.js/Express/Socket.IO): Real-time control interface with a "Space/Starfield" design. Instant communication with the Manager via Socket.IO.
3. PostgreSQL Database: Storage for bot accounts, users, language preferences, and statistics.
The load balancing system automatically selects the bot with the fewest friends (< 900) for each new friend request. If all bots are full, a new bot is automatically created.
Architecture
Distributed multi-service Docker architecture:
- lobbybot2.0-discord/ (Node.js): Central Manager
- 'src/managers/': Main managers (Bots, Database, User, API, Discord)
- 'src/commands/': Discord commands (/login, /add, /list, /shop, /locker, /admin...)
- 'src/actions/': Fortnite action logic (Skin, Party, Friends)
- 'src/utils/': Utilities (i18n Locales, helpers)
- lobbybot2.0-website/ (Node.js/Express): Web Dashboard
- Express + Socket.IO backend for real-time communication
- HTML5/CSS3/Vanilla JS frontend with "Space/Starfield" design
- Bot status display, friends, controls (Kick, Promote, Privacy)
- PostgreSQL: Shared database (accounts, users, preferences)
- Docker Compose: Orchestration of all three services
Skills developed
Distributed Architecture & Docker
Design and deployment of a multi-service architecture with Docker Compose: Node.js Manager, Web Dashboard, and PostgreSQL database communicating in real-time.
Community & Product Management
Management of a 8,500+ member Discord community, user feedback handling, continuous product evolution over 5+ years, and funding through Epic Games creator code.
Real-time Communication (Socket.IO)
Implementation of bidirectional real-time communications between the Web Dashboard and Manager via Socket.IO for instant bot control.
Automation & Load Balancing
Intelligent load distribution system between bots, automatic creation of new bots, and automatic restart on crash or server reboot.
Code highlights
1// LobbyBot 2.0 - Bot Manager avec load balancing
2class BotManager {
3 constructor() {
4 this.bots = new Map(); // Map<botId, BotInstance>
5 this.FRIEND_LIMIT = 900;
6 }
7
8 async selectOptimalBot() {
9 // 1. Filtrer les bots disponibles (< 900 amis)
10 const availableBots = Array.from(this.bots.values())
11 .filter(bot => bot.isReady && bot.friendCount < this.FRIEND_LIMIT)
12 .sort((a, b) => a.friendCount - b.friendCount);
13
14 if (availableBots.length > 0) {
15 // 2. Retourner le bot avec le moins d'amis
16 const selectedBot = availableBots[0];
17 return selectedBot;
18 }
19
20 // 3. Si tous les bots sont pleins, creer automatiquement un nouveau bot
21 const newBot = await this.createNewBot();
22 return newBot;
23 }
24
25 async addFriend(epicUsername) {
26 const bot = await this.selectOptimalBot();
27
28 try {
29 await bot.addFriend(epicUsername);
30 bot.friendCount++;
31
32 // Sauvegarder en base de donnees PostgreSQL
33 await db.query(
34 'UPDATE bots SET friend_count = $1 WHERE account_id = $2',
35 [bot.friendCount, bot.accountId]
36 );
37
38 return { success: true, bot: bot.displayName };
39 } catch (error) {
40 return { success: false, error: error.message };
41 }
42 }
43}This code implements the Bot Manager's load balancing system. The selectOptimalBot() method filters available bots (< 900 friends), sorts them by ascending friend count, and returns the least loaded one. If all bots are full, a new bot is automatically created from the PostgreSQL pool.
1// LobbyBot 2.0 - Dashboard Socket.IO Server
2const express = require('express');
3const socketIo = require('socket.io');
4const server = require('http').createServer(express());
5const io = socketIo(server);
6
7// Connexion au Discord Manager via Socket.IO
8const managerSocket = require('socket.io-client')('http://localhost:3001');
9
10io.on('connection', (clientSocket) => {
11 // 1. Envoyer etat initial des bots au client
12 managerSocket.emit('get_all_bots_status', (botsData) => {
13 clientSocket.emit('initial_state', {
14 bots: botsData.bots,
15 totalFriends: botsData.totalFriends,
16 activeBots: botsData.activeBots
17 });
18 });
19
20 // 2. Ecouter les mises a jour en temps reel du Manager
21 managerSocket.on('bot_status_update', (data) => {
22 io.emit('bot_update', {
23 botId: data.botId,
24 displayName: data.displayName,
25 friendCount: data.friendCount,
26 status: data.status
27 });
28 });
29
30 // 3. Actions depuis le dashboard vers le Manager
31 clientSocket.on('kick_friend', async (data) => {
32 managerSocket.emit('kick_friend', {
33 botId: data.botId,
34 friendId: data.friendId
35 }, (response) => {
36 clientSocket.emit('kick_response', response);
37 });
38 });
39});This code handles real-time communication between the Web Dashboard and Discord Manager via Socket.IO. The Dashboard server listens for client connections, sends initial bot state, propagates real-time updates and handles user actions (kick, skin change).
Results & outcomes
LobbyBot 2.0 has been an active project since 2020 with concrete results:
- 8,500+ Discord members actively following the project and using bots daily
- Functional multi-bot system with intelligent load balancing and automatic new bot creation
- Real-time web dashboard enabling monitoring and control of all bots
- Official Epic Games authorization obtained after multiple direct exchanges
- Self-funded through the Epic Games creator code system (10% commission)
- 5+ years of continuous maintenance, with major evolutions (Python → Node.js, scripts → Docker architecture)
- Full internationalization in 4 languages (FR/EN/ES/DE) for the international community
This project, started at age 16 during COVID, became and remains my biggest personal project, demonstrating my ability to lead a project from A to Z over the long term.
Reflection & learnings
LobbyBot 2.0 is the project that taught me the most outside of school:
- 015 years of technical evolution took me from simple Python scripts to a complete distributed architecture with Docker. Each iteration pushed me to learn new technologies to solve concrete problems: Node.js for performance, PostgreSQL for persistence, Socket.IO for real-time, Docker for deployment.
- 02Managing a community of 8,500+ members taught me essential non-technical skills: communication, expectation management, feature prioritization based on user feedback, and the responsibility of maintaining a daily-used service.
- 03Contact with Epic Games taught me to interact professionally with a large company, present my project convincingly, and respect their terms of use.
- 04Long-term maintenance is the most important lesson: APIs change, servers crash, users' needs evolve. This project taught me the value of robust architecture, automation (automatic restart, load balancing), and documentation.
This project proves that a passionate side project can become something significant with perseverance and continuous improvement.