ChatVoid - Behind the Build

Engineering ChatVoid

ChatVoid is a web-based real-time messaging platform I built to make online communication simple, private, and fast. Instead of requiring users to share phone numbers or email addresses, ChatVoid lets people connect through private chat spaces called Voids.

My goal was to create a lightweight communication system that prioritized privacy, security, speed, and ease of use. Every engineering decision — from Firebase-powered real-time messaging to client-side AES encryption — was made to create a platform that feels simple on the surface but powerful underneath.

The product vision was simple: users should be able to start chatting quickly without giving away personal contact information. That idea shaped the entire design, from the token-based joining system to the temporary session experience.

HTML5 CSS3 JavaScript Firebase Firestore Anonymous Auth CryptoJS AES Responsive Design

Technical Architecture

Frontend-first interface

I used HTML, CSS, and vanilla JavaScript to build the user interface and client-side logic. This kept the platform lightweight, responsive, and easier to debug.

Firebase backend

Firebase powers the backend of ChatVoid, including chat room creation, joining Voids, anonymous user sessions, and real-time message syncing.

Void system

Voids are private chat spaces that users can create and join using a token. This removes the need for phone numbers, email addresses, or traditional friend lists.

Encrypted message storage

Message content is encrypted with CryptoJS AES before being stored in Firebase. This adds a privacy layer so stored messages are not saved as readable plain text.

Core Features Engineered

Real-time messaging

Messages are synchronized instantly through Firebase, allowing users inside the same Void to communicate without refreshing the page.

Create Voids

Users can initialize a new Void, which creates a private communication space in Firebase where messages can be stored and synced.

Join Voids by token

Instead of usernames, phone numbers, or emails, users join existing Voids through a generated token. This makes the connection flow quick and private.

Anonymous access

Firebase Anonymous Authentication allows users to enter the app without traditional login, reducing friction while still giving each session a unique identity.

Edit, copy, and delete messages

Users can manage their own messages through quick actions, making the chat experience feel more complete and app-like.

Responsive dark UI

The interface uses a dark, space-inspired design that works across desktop and mobile screens while matching the ChatVoid brand.

Security & Privacy Design

ChatVoid was designed around the idea that users should not need to reveal personal contact information just to communicate.

To support that, the app uses anonymous access, token-based Void joining, and encrypted message content. Before a message is written to Firebase, the text is encrypted using AES through the CryptoJS library. When the message is displayed in the app, it is decrypted on the client side.

This means Firebase stores encrypted message content instead of readable plain text. This is not the same as full end-to-end encryption, but it does add an extra privacy layer on top of Firebase’s built-in security features.

Challenges & Solutions

Challenge 01

Building a real-time messaging system

The biggest technical challenge was making the chat feel live. Messages needed to appear quickly for every person inside the same Void, and the experience could not depend on users refreshing the page.

A messaging app feels broken if updates are slow or inconsistent. So the system needed to keep each connected user synchronized while staying simple enough to maintain.

Solution

I used Firebase Firestore real-time listeners to update the chat whenever new messages were added. This allowed the app to react to database changes instantly and display messages across connected clients in real time.

Challenge 02

Designing the Void system

I did not want ChatVoid to feel like a normal messaging app that requires accounts, phone numbers, email addresses, or friend lists. The challenge was creating a new connection model that was still easy for users to understand.

If the joining process was confusing, users would leave before reaching the chat. The system needed to feel private but also fast.

Solution

I created the concept of Voids: private rooms that users can create and join using a generated token. This made the product easier to explain and removed the need for personal contact sharing.

Challenge 03

Protecting user conversations

Since ChatVoid is built around private communication, storing plain-text messages would have weakened the privacy story. Even though Firebase already provides secure infrastructure, I wanted message content to have an additional privacy layer before reaching the database.

The challenge was adding encryption without making the app slow or difficult to use. The encryption needed to happen automatically, so users could still send messages normally.

Solution

I implemented client-side AES encryption using CryptoJS. Messages are encrypted before being stored in Firebase and decrypted when displayed inside the app. This keeps the chat experience smooth while reducing plain-text exposure in the database.

Challenge 04

Reducing login friction while keeping sessions usable

Traditional login systems can make simple chat apps feel heavy. Requiring accounts would have gone against the goal of quick, private communication.

At the same time, the app still needed a way to identify users during a session so messages could be organized and message actions could work properly.

Solution

I used Firebase Anonymous Authentication. This allowed users to enter the platform without creating a full account while still giving each session a unique identity behind the scenes.

Challenge 05

Keeping the interface simple across devices

Chat apps need to feel comfortable on both large screens and phones. On mobile especially, the layout has to make room for messages, inputs, buttons, and navigation without becoming cluttered.

The challenge was balancing a futuristic dark design with practical usability.

Solution

I built a responsive UI with CSS media queries, clean spacing, and a focused layout. The app keeps the main chat experience centered while adapting controls for smaller screens.

Technical Takeaways

Real-time apps require careful syncing between frontend state and backend data.
Firebase can make live messaging faster to build and easier to scale.
Privacy should influence product design from the beginning.
Client-side encryption can add a useful privacy layer when storing messages.
Anonymous authentication can reduce friction while still supporting user sessions.
A strong product idea can come from removing unnecessary steps, not adding more features.
Responsive design is extremely important for chat products because users may join from any device.

Conclusion

ChatVoid became more than a simple chat page. It became a real-time communication system with private Voids, token-based joining, anonymous sessions, encrypted message storage, and a responsive dark interface.

This project strengthened my understanding of Firebase, real-time databases, client-side security, frontend engineering, and product design. Most importantly, it taught me that good software is not always about adding more features — sometimes it is about removing friction and protecting the user experience.