Xice team

Inspiration

Developers often need small utilities while building and testing applications: secure password generation, realistic test identities, valid test card numbers, UUIDs, network information, and data validators. These tools usually exist across different websites, each with a different interface, limitations, and level of reliability.

I created Rad to bring these everyday developer utilities together in one fast, secure, and beautifully designed platform. The goal was to reduce context switching and give developers a single place where they can quickly generate, validate, and manage the test data they need.

What it does

Rad is an all-in-one developer utility platform designed to make development, testing, and debugging workflows faster.

It currently provides tools for:

• Generating valid test credit card numbers using the Luhn algorithm
• Looking up BIN information and validating card numbers
• Generating realistic test identities for different countries
• Creating secure and customizable passwords
• Generating and validating IPv4, IPv6, and MAC addresses
• Performing DNS and nameserver lookups
• Generating UUIDs in different versions
• Validating UUIDs and IBAN numbers
• Generating domain names, subnet masks, and network information

Rad also includes a complete user system with registration, email verification, login, password recovery, profile management, generation history, device management, and secure logout.

The generated information is intended strictly for development, quality assurance, interface prototyping, and software testing.

How I built it

I built Rad as a full-stack web application with Go and the Fiber framework powering the backend.

The backend is organized into separate routes, middleware, models, utilities, and reusable libraries. Each developer tool has its own logic and API endpoint, making the project easier to maintain and extend.

The main technologies used include:

• Go for the application and utility logic
• Fiber for the HTTP server and REST API
• MongoDB for users, generated data, verification codes, and history
• Redis support for caching and rate-limiting improvements
• JWT for authentication and session handling
• bcrypt for secure password hashing
• SMTP email for account verification and password recovery
• Tailwind CSS for the responsive user interface
• Zap for structured application logging

I also added validation middleware, rate limiting, CORS configuration, CSRF protection for web pages, security headers, response compression, request-size limits, health checks, and graceful server shutdown.

Challenges I ran into

One of the biggest challenges was creating several completely different utilities while keeping the backend architecture consistent. A password generator, identity generator, card validator, and DNS lookup tool all require different logic, but they still need to follow the same validation, authentication, error-handling, and response patterns.

Building the authentication flow was another major challenge. Registration required more than simply saving a user. I had to handle password-strength validation, hashing, email verification codes, token expiration, password recovery, and multiple logged-in devices.

Generating realistic test identities for different countries was also challenging because the returned data had to remain consistent across personal, location, banking, and contact fields.

Finally, I had to balance usability with security. Developer tools should feel instant and simple, but public utility endpoints can easily be abused. This required careful use of request validation, authentication middleware, rate limits, security headers, and request-size restrictions.

Accomplishments that I'm proud of

I am especially proud that Rad became more than a collection of disconnected generators. It is a complete platform with a consistent interface, reusable backend architecture, persistent user accounts, generation history, and device-aware authentication.

Some of the accomplishments I am most proud of are:

• Building the backend with Go and Fiber from the ground up
• Creating a modular collection of generators, validators, and network tools
• Implementing email verification and password recovery
• Supporting secure multi-device user sessions
• Generating realistic country-based test identities
• Protecting endpoints with validation and rate limiting
• Creating a responsive interface that works across different screen sizes
• Adding production-focused features such as health checks, structured logging, compression, and graceful shutdown

Most importantly, I created something that I would genuinely use during my own development workflow.

What I learned

Building Rad taught me how to structure a larger Go application beyond a basic collection of routes and handlers. I learned how to separate API routing, middleware, database models, configuration, utility libraries, and infrastructure concerns into maintainable modules.

I also gained a much deeper understanding of authentication security, including password hashing, JWT validation, expiring verification tokens, password-reset flows, and device session management.

Working with MongoDB helped me understand how generated data, users, tokens, and history can be modeled and queried efficiently. I also learned that input validation, predictable error responses, logging, and rate limiting are just as important as implementing the main feature itself.

On the frontend, I learned how to turn several technically different tools into one consistent and accessible user experience.

What's next for Rad

The next step is to turn Rad from a functional developer toolkit into a production-ready platform.

I plan to add:

• Automated unit, integration, and end-to-end tests
• Interactive API documentation with OpenAPI or Swagger
• Docker and Docker Compose support
• A continuous integration and deployment pipeline
• More advanced caching and rate limiting with Redis
• Additional developer tools and data generators
• Improved generation history with searching and filtering
• Export options such as JSON and CSV
• API keys for developers who want to use Rad programmatically
• Improved accessibility and mobile usability
• Usage analytics and performance monitoring
• A redesigned dashboard with saved presets and favorite tools

The long-term vision is for Rad to become a reliable developer workspace where engineers can generate test data, validate information, inspect network values, and access frequently used utilities without moving between multiple services.

Built With

• fiber
• go
• tailwindcss