DEV Community: Puffer

The Bingo Revolution: How I Built the World's Most Immersive 3D Bingo Platform

Puffer — Wed, 28 Jan 2026 20:18:34 +0000

The Dream: Bingo Reimagined
For years, I watched digital bingo games languish in flat, uninspired interfaces that felt more like spreadsheets than entertainment. The classic game I loved—with its tactile daubers, vibrating anticipation, and communal excitement—had lost its soul in translation to digital. So I asked a dangerous question: What if bingo wasn't just cards and numbers, but an experience?

Sixteen months later, I'm launching what I genuinely believe is the finest bingo platform in existence. Not just another bingo game, but a living, breathing 3D environment where balls tumble through space, cards feel tangible, and victory erupts in showers of digital confetti. Here's how I built it, what nearly broke me, and the solutions that brought it to life.

The Technical Stack: Ambitious From Day One
I chose my weapons carefully:
WebGL/Three.js for buttery-smooth 3D rendering in the browser
React for a dynamic, component-based UI that feels instantaneous
Node.js with Socket.io for real-time multiplayer communication
AWS Lambda for a serverless backend that scales with our players
Redis for lightning-fast game state management

The vision was clear: cinematic 3D visuals with the accessibility of a web app, no downloads required.
I chose my weapons carefully:

WebGL/Three.js for buttery-smooth 3D rendering in the browser
React for a dynamic, component-based UI that feels instantaneous
Node.js with Socket.io for real-time multiplayer communication
AWS Lambda for a serverless backend that scales with our players
Redis for lightning-fast game state management

The vision was clear: cinematic 3D visuals with the accessibility of a web app, no downloads required.

Challenge 1: WebGL Performance in a Massively Multiplayer Setting
The Problem
My initial 3D prototype was gorgeous - individually. Each bingo ball had realistic physics, reflections, and shadows. Then I simulated 50 players. The frame rate plummeted. Browsers crashed. The beautiful 3D world had become a computational furnace.
The Solution
I implemented a hybrid rendering system that dynamically adjusts visual fidelity based on:

Player device capability (auto-detected through benchmark tests)
Number of active players in a room
Individual player distance in the 3D space (using a custom Level of Detail system)

The breakthrough came when I realized not everything needed to be 3D. Static elements like backgrounds and UI panels use optimized 2D assets, while interactive elements (balls, cards, daubers) get the full 3D treatment. This reduced draw calls by 70% without sacrificing the immersive feel.

Challenge 2: Real-Time Synchronization Across Continents
The Problem
Bingo is unforgiving when it comes to timing. A half-second delay in number calling can mean the difference between a joyous "BINGO!" and frustrated accusations of cheating. With players from Tokyo to Toronto, network latency threatened to ruin the experience.
The Solution
I built a region-aware game server architecture using AWS Lambda@Edge functions. When a player joins:

Their location is determined via IP (with permission)
They're automatically routed to the nearest game server (Oregon, Frankfurt, or Singapore)
All game servers sync via a master Redis instance every 100ms

For the number calling itself, I implemented a buffer-and-catch-up system. If a player's connection lags, they receive batched updates that visually appear seamless. The secret sauce? Client-side prediction for daubing actions, with server reconciliation that's invisible to the player.

Challenge 3: The Serverless Scaling Paradox
The Problem
AWS Lambda promised infinite scale, but cold starts during sudden player influxes (like when a game starts) created 3–5 second delays. In a fast-paced bingo game, that's an eternity.
The Solution
I created a predictive warming system:

Monitor player queuing patterns
Pre-warm Lambda functions 90 seconds before expected game starts
Maintain a "ready pool" of warm functions during peak hours
Implemented using CloudWatch Events and a small always-on EC2 instance that manages the warming schedule

The result? 99.9% of game starts now occur with sub-200ms Lambda readiness.

Challenge 4: Making 3D Accessible
The Problem
Not everyone has a gaming PC. The experience needed to shine on tablets, older laptops, and even some mobile devices without turning them into space heaters.
The Solution
I developed progressive enhancement tiers:

Tier 1 (High-End Devices): Full shadows, reflections, particle effects (60 FPS)
Tier 2 (Mid-Range): Basic lighting, simplified physics (45 FPS)
Tier 3 (Low-End): Flat shading, minimal particles, 2D balls (30 FPS)

The magic? Players don't choose - the system automatically selects the optimal tier and smoothly transitions between them if device performance changes mid-game.

What Emerged From the Struggle
The platform now features:

Procedurally generated 3D bingo halls with different themes (classic, space, underwater)
Realistic physics where balls bounce and roll before settling
Social spaces where players can "sit" near friends in the virtual hall
Customizable 3D daubers with satisfying visual and sound feedback Spectator mode that lets you float around the bingo hall watching others play

The Human Lessons
Beyond the code, I learned:

Optimization is a feature. Players may not notice 60 FPS, but they absolutely notice 15 FPS.
The best technology is invisible. When players say "the game just feels right," you've succeeded.
Serverless doesn't mean thoughtless. It requires reimagining architectures around statelessness.

Looking Forward
The platform launches soon, but already I'm dreaming of:

VR/AR support using the same WebGL core
User-generated content tools for custom bingo halls
AI-powered hosts that learn players' names and styles

Try It Yourself
I'm opening beta access to readers of this article.
Visit https://github.com/puffer-git and use code BINGOBLOG for early access.
I'd love to hear what you think works - and what doesn't.
Because in the end, this wasn't just about building a better bingo game. It was about proving that even the most classic games can find new life when we're willing to reimagine them completely.

Built with Three.js, React, Node, and probably too much coffee.

# 🔐 Login Backend with Express, AWS Lambda and Dynamo DB

Puffer — Fri, 19 Dec 2025 17:27:42 +0000

A robust, scalable backend API for authentication and user management built with Node.js and Express. Features secure login/signup, role-based access control, and seamless integration with AWS DynamoDB, Stripe, and Brevo.

✨ Features

🔐 Authentication System - Secure user registration and login with JWT tokens
👥 Role-Based Access Control - Four-tier role system (User, Agent, Master, Super Admin)
🔒 Password Security - Bcrypt password hashing for secure password storage
📊 DynamoDB Integration - NoSQL database operations with AWS DynamoDB
💳 Payment Processing - Stripe integration for payment handling
📧 Email Services - Brevo integration for email communications
🚀 Serverless Ready - Can be deployed as AWS Lambda function
🛡️ Security Middleware - JWT authentication and authorization middleware
📝 Input Validation - Request validation for signup and login endpoints
🏗️ MVC Architecture - Clean separation of concerns with Models, Views, and Controllers

🛠️ Tech Stack

Runtime: Node.js
Framework: Express.js
Database: AWS DynamoDB
Authentication: JWT (JSON Web Tokens)
Password Hashing: bcryptjs
Payment: Stripe
Email: Brevo (formerly Sendinblue)
Deployment: Serverless (AWS Lambda compatible)

📋 Prerequisites

Before you begin, ensure you have the following installed:

Node.js (v14 or higher)
npm or yarn
AWS Account (for DynamoDB)
Stripe Account (for payment processing)
Brevo Account (for email services)

🚀 Installation

Clone the repository

   git clone https://github.com/puffer-git/login-dynamo-db.git
   cd login-dynamo-db

Install dependencies

   npm install

Set up environment variables

Create a .env file in the root directory with the following variables:

   # Server Configuration
   ENVIRONMENT=development
   PORT=4000

   # JWT Configuration
   JWT_SECRET=your-super-secret-jwt-key-change-this-in-production
   JWT_EXPIRES_IN=7d

   # AWS DynamoDB Configuration
   AWSREGION=us-east-1
   AWSENDPOINT=https://dynamodb.us-east-1.amazonaws.com
   AWSACCESSKEYID=your-aws-access-key-id
   AWSSECRETKEY=your-aws-secret-access-key

   # Stripe Configuration (optional)
   STRIPE_SECRET_KEY=your-stripe-secret-key

   # Brevo Configuration (optional)
   BREVO_API_KEY=your-brevo-api-key

Set up DynamoDB tables

Create a DynamoDB table named users with:

Partition Key: id (String)
Enable point-in-time recovery (recommended for production)

🏃 Running the Application

Development Mode

npm run dev

The server will start on http://localhost:4000 with auto-reload enabled.

Production Mode

npm start

Serverless Deployment

When ENVIRONMENT=production, the application exports a serverless handler for AWS Lambda deployment.

📚 API Documentation

Base URL

Development: http://localhost:4000
Production: Your deployed endpoint

Authentication Endpoints

Register a New User

POST /auth/signup
Content-Type: application/json

{
  "player_name": "johndoe",
  "email": "john@example.com",
  "password": "securePassword123",
  "name": "John Doe" // optional
}

Response (201 Created)

{
  "success": true,
  "message": "User created successfully",
  "data": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
  }
}

Error Responses

409 Conflict - Player name or email already exists
400 Bad Request - Validation error
500 Internal Server Error - Server error

Login

POST /auth/login
Content-Type: application/json

{
  "identifier": "johndoe", // Can be email or player_name
  "password": "securePassword123"
}

Response (200 OK)

{
  "success": true,
  "message": "Login successful",
  "data": {
    "user": {
      "role": "user",
      "player_name": "johndoe",
      "email": "john@example.com",
      "name": "John Doe"
    },
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
  }
}

Error Responses

401 Unauthorized - Invalid credentials
400 Bad Request - Validation error
500 Internal Server Error - Server error

Authentication Header

For protected routes, include the JWT token in the Authorization header:

Authorization: Bearer <your-jwt-token>

🏗️ Project Structure

login-dynamo-db/
├── app/
│   ├── constants/
│   │   ├── roles.js          # Role definitions and hierarchy
│   │   └── tables.js         # DynamoDB table configurations
│   ├── controllers/
│   │   └── auth/
│   │       ├── login/
│   │       │   ├── login.js
│   │       │   └── loginValidation.js
│   │       └── signup/
│   │           ├── signup.js
│   │           └── signupValidation.js
│   ├── db/
│   │   ├── dynamoClient.js   # DynamoDB client configuration
│   │   └── index.js          # Database exports
│   ├── middleware/
│   │   └── auth.js           # Authentication & authorization middleware
│   ├── models/
│   │   ├── BaseModel.js      # Base model for DynamoDB operations
│   │   └── UserModel.js      # User model with business logic
│   ├── routes/
│   │   ├── auth.js           # Authentication routes
│   │   └── index.js          # Route aggregator
│   ├── utils/
│   │   └── userUtils.js      # User utility functions
│   └── index.js              # Express app configuration
├── index.js                   # Application entry point
├── package.json
└── README.md

🔐 Role System

The application supports a four-tier role hierarchy:

USER - Basic user role (default)
AGENT - Agent-level permissions
MASTER - Master-level permissions
SUPER_ADMIN - Highest level of access

Roles are checked using middleware:

authenticate - Verifies JWT token
authorize(roles) - Checks if user has specific role(s)
requireMinimumRole(role) - Checks if user has minimum role level

🧪 Development

Code Style

Follow existing code patterns
Use meaningful variable and function names
Add JSDoc comments for functions
Keep functions focused and single-purpose

Adding New Features

Create feature branch: git checkout -b feature/your-feature-name
Follow MVC architecture:
- Models in app/models/
- Controllers in app/controllers/
- Routes in app/routes/
- Middleware in app/middleware/
Add validation for user inputs
Write clear error messages
Test your changes thoroughly
Submit a pull request

🤝 Contributing

Contributions are welcome! Please follow these steps:

Fork the repository
Create your feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

Contribution Guidelines

Write clear, readable code
Add comments for complex logic
Follow the existing code structure
Test your changes before submitting
Update documentation if needed

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

📧 Contact

Developer: Puffer

📧 Email: devpuffer0807@gmail.com
💬 Telegram: @devpuffer0807

🙏 Acknowledgments

Built with Express.js
Database powered by AWS DynamoDB
Payment processing by Stripe
Email services by Brevo

📄 License

MIT License - feel free to use this project for your own purposes!

⭐ If you find this project helpful, please consider giving it a star!

AI Twin — Voice Cloning with Text-to-Speech

Puffer — Tue, 16 Dec 2025 14:52:59 +0000

An open-source project for creating AI voice clones using Coqui TTS (XTTS v2). This project enables you to generate natural-sounding speech in any voice by providing a sample audio file and text input.

🎯 Features

Voice Cloning: Clone any voice from a sample audio file
Multilingual Support: Works with multiple languages (English, Spanish, French, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese, Japanese, and more)
High-Quality Output: Powered by Coqui TTS XTTS v2 model for natural-sounding speech
Easy to Use: Simple notebook-based interface for quick voice generation
GPU Support: Automatically uses CUDA if available for faster processing

📋 Requirements

Python 3.7+
PyTorch
CUDA-capable GPU (optional, but recommended for faster processing)
Google Colab or Jupyter Notebook environment

🚀 Installation

Clone this repository:

git clone https://github.com/yourusername/ai-twin.git
cd ai-twin

Install dependencies:

pip install -U scipy torch

Install Coqui TTS:

git clone https://github.com/idiap/coqui-ai-TTS.git
cd coqui-ai-TTS
pip install -e .

💻 Usage

Open TorTTS_API.ipynb in Jupyter Notebook or Google Colab
Run the first cell to install dependencies and clone Coqui TTS
Run the second cell to initialize the TTS model
Upload a voice sample (MP3 or WAV format) - this will be used as the reference voice
Upload a text file containing the text you want to convert to speech
Run the final cell to generate the audio output
Download the generated audio file

Example Workflow

# Initialize TTS
from TTS.api import TTS
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# Generate speech
tts.tts_to_file(
    text="Your text here",
    speaker_wav="path/to/voice_sample.mp3",
    language="en",
    file_path="output.wav"
)

📝 Supported Languages

English, Spanish, French, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese (Simplified), Japanese, and more.

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

📄 License

This project is open source and available under the MIT License.

📧 Contact

Email: devpuffer0807@gmail.com
Telegram: @devpuffer0807

🙏 Acknowledgments

Coqui TTS - The amazing text-to-speech library that powers this project
XTTS v2 - The voice cloning model used in this project

⚠️ Disclaimer

This tool is for educational and research purposes. Please ensure you have proper authorization before cloning voices, especially for commercial use. Always respect privacy and consent when working with voice data.

Made with ❤️ by the open source community

Building a Simple, Secure File Upload System with AWS Lambda and S3

Puffer — Mon, 15 Dec 2025 07:57:20 +0000

Almost every web app needs file uploads at some point. Images, documents, exports — it’s always there.

But setting up file uploads often turns into more work than expected. You end up managing servers, worrying about security, and fixing edge cases that keep coming back. I wanted something easier and more reliable.

So I built a small serverless project that uploads files to Amazon S3 using AWS Lambda and returns a CloudFront signed URL.

https://github.com/puffer-git/aws-lambda-file-upload

Why I Built This
I’ve seen many projects handle uploads with custom backends and public S3 buckets. It works at first, but it’s not great long term.

I wanted:

No servers to maintain
Automatic scaling
Secure file access
Simple code that’s easy to reuse
AWS already provides everything needed for this, so the goal was to connect the pieces cleanly.

How It Works
The flow is very simple:

The client sends a file as multipart/form-data
Lambda receives the request
The file is uploaded to S3
A signed CloudFront URL is created The URL is returned to the client That’s it. Lambda scales automatically and you only pay when it runs.

They allow:

Private file storage
Temporary access to files
Better security by default
Fast delivery through CloudFront This is useful for user uploads, documents, or any files that shouldn’t be public forever.

Keeping It Lightweight

This project is intentionally small.
Minimal dependencies
No heavy frameworks
Easy configuration with environment variables
That makes it easier to understand, maintain, and debug.

When to Use This
This setup is a good fit if you:

Use AWS

Prefer serverless architecture
Need secure file uploads
Want something easy to plug into an existing app
It’s not meant for complex media pipelines — just a clean solution for common upload needs.

Final Thoughts
File uploads don’t need to be complicated.

With AWS Lambda, S3, and CloudFront, you can build a secure and scalable upload system with very little code.

That’s what this project is about — keeping things simple and practical.

If you want it even shorter, more casual, or more technical, tell me the tone and I’ll rewrite it.