Trustroop is a trust and reputation platform for the web that helps people evaluate the trustworthiness of anything with a unique URL.
Users can submit positive or negative reviews for digital entities such as websites, e-commerce products, companies, brands, services, and public profiles. Anyone can then check a URL and review its Trust Score before making a decision.
Trustroop also includes a browser extension that automatically detects the URL a user is visiting and provides trust information and alerts when relevant.
The project is designed as a scalable, event-driven microservice architecture using a modern TypeScript stack, RabbitMQ, PostgreSQL, Docker, and Turborepo.
- 🔎 URL Trust Score — Check the reputation and trustworthiness of any supported URL.
- 👍 Positive & Negative Reviews — Users can share their experience with digital entities.
- 🌐 Universal URL Reputation — Designed to support websites, products, companies, brands, profiles, services, and other URL-based entities.
- 🚨 Browser Alerts — The Chrome extension can automatically detect the URL currently being visited and provide trust-related information.
- 👤 User System — User accounts and reputation-related interactions.
- ⚡ Event-Driven Architecture — Services communicate asynchronously through RabbitMQ.
- 🧩 Microservices — Core functionality is separated into independently deployable services.
- 📦 Monorepo Architecture — Managed with Turborepo for efficient development and shared tooling.
- 🐳 Dockerized Deployment — Development and production environments are containerized for consistent deployment.
- 🛡️ Schema Validation — Zod is used for runtime validation and type-safe data boundaries.
- 🗄️ Type-Safe Database Access — Prisma provides database access and schema management with PostgreSQL.
Trustroop is built using a microservice-oriented and event-driven architecture.
The repository is organized as a Turborepo monorepo containing multiple applications and services that work together to provide the complete platform.
┌─────────────────────┐
│ Next.js Web │
│ Application │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ NestJS API │
│ API Gateway/App │
└──────────┬──────────┘
│
│ Events / Messages
▼
┌─────────────────────┐
│ RabbitMQ │
│ Message Broker │
└──────────┬──────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
▼ ▼ ▼
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ URL Service │ │ User Service │ │ Other Services │
│ NestJS │ │ NestJS │ │ NestJS │
└───────┬────────┘ └───────┬────────┘ └───────┬────────┘
│ │ │
└──────────────────┼──────────────────┘
▼
┌─────────────────┐
│ PostgreSQL │
│ + Prisma │
└─────────────────┘
┌─────────────────────┐
│ Chrome Extension │
│ Browser │
└──────────┬──────────┘
│
▼
┌──────────────┐
│ NestJS API │
└──────────────┘
The exact service boundaries may evolve as the platform grows, but the architecture is intentionally designed to allow individual components to scale and evolve independently.
The main backend API is built with NestJS and provides the application layer for clients and internal services.
Responsibilities include:
- API endpoints
- Authentication and authorization
- User operations
- Review operations
- Trust score operations
- URL-related operations
- Service communication
- Request validation
The URL-focused service handles the reputation and identity of URLs.
It provides the foundation for determining whether a URL has existing Trustroop information and connecting it with reviews, trust scores, and related data.
The web application is built with Next.js and provides the primary user-facing interface.
Users can use the web application to:
- Check a URL
- View trust information
- Submit reviews
- Explore reputation data
- Interact with the Trustroop platform
The Chrome extension extends Trustroop directly into the browsing experience.
When installed, it can detect the URL a user is currently visiting and communicate with the Trustroop platform to provide relevant trust information or alerts.
This allows Trustroop to work proactively rather than requiring users to manually copy and paste every URL into the platform.
The project also contains a dedicated blog application for publishing educational, informational, and SEO-focused content related to online trust, digital reputation, websites, products, companies, and internet safety.
Trustroop uses RabbitMQ for asynchronous communication between services.
Instead of tightly coupling every service through synchronous HTTP requests, events can be published and consumed independently.
For example:
User Action
│
▼
API
│
▼
Publish Event
│
▼
RabbitMQ
│
├──────────────► Service A
│
├──────────────► Service B
│
└──────────────► Worker
This approach provides several architectural benefits:
- Reduced coupling between services
- Asynchronous processing
- Better scalability
- Improved fault isolation
- Easier background processing
- Ability to add new consumers without changing the original producer
RabbitMQ therefore acts as an important part of the platform's distributed architecture.
Trustroop uses PostgreSQL as its primary relational database.
Prisma is used as the database ORM and provides:
- Type-safe database queries
- Schema management
- Database migrations
- Strong TypeScript integration
- Structured data access
Zod is used for runtime schema validation at application boundaries, helping ensure that incoming data conforms to expected structures.
| Technology | Purpose |
|---|---|
| TypeScript | Primary programming language |
| Next.js | Web applications and frontend |
| NestJS | Backend APIs and services |
| Turborepo | Monorepo and build orchestration |
| RabbitMQ | Event-driven messaging |
| PostgreSQL | Relational database |
| Prisma | Database ORM and type-safe data access |
| Zod | Runtime schema validation |
| Docker | Containerization |
| Docker Compose | Local and server orchestration |
| Chrome Extension | Browser-based URL monitoring |
Trustroop uses Turborepo to manage the project as a monorepo.
This makes it possible to maintain multiple applications and services in a single repository while sharing common tooling, configurations, and packages.
A simplified structure looks like:
trustroop/
├── apps/
│ ├── api/
│ ├── blog/
│ ├── chrome/
│ └── ...
│
├── packages/
│ └── ...
│
├── compose.development.yaml
├── docker-compose.yaml
├── package.json
├── pnpm-workspace.yaml
└── turbo.json
Make sure you have the following installed:
- Node.js
<NODE_VERSION> - pnpm
- Docker
- Docker Compose
- Git
Verify your Node.js version:
node -vVerify pnpm:
pnpm -vgit clone git@github.com:tanvir0604/trustroop.git
cd trustroopInstall all monorepo dependencies:
pnpm installEach application/service may require its own environment configuration.
Create the required .env files inside the relevant applications.
For example:
apps/
├── api/
│ └── .env
├── blog/
│ └── .env
├── chrome/
│ └── .env
└── ...
Never commit production secrets, API keys, database credentials, or other sensitive environment variables to the repository.
Start the development infrastructure using Docker Compose:
sudo docker compose -f compose.development.yaml up -dThen start the Turborepo development environment:
pnpm devThe development workflow is therefore:
git clone git@github.com:tanvir0604/trustroop.git
cd trustroop
pnpm install
# Configure .env files
sudo docker compose -f compose.development.yaml up -d
pnpm devTrustroop is containerized to simplify deployment and maintain consistency between environments.
Build the production Docker images:
sudo docker compose buildAfter building the images, tag them with your Docker Hub repository names and push them to Docker Hub.
Example:
docker tag <local-image> <dockerhub-username>/<image>:latest
docker push <dockerhub-username>/<image>:latestRepeat this for the required Trustroop services.
On the production server, pull the required images and start the services:
sudo docker compose up -dDocker Compose will start the required Trustroop containers and supporting infrastructure.
Source Code
│
▼
pnpm
│
▼
Turborepo
│
├── Next.js
├── NestJS
└── Chrome
Docker Compose
│
├── PostgreSQL
└── RabbitMQ
Source Code
│
▼
Docker Build
│
▼
Docker Images
│
▼
Docker Hub
│
▼
Production Server
│
▼
Docker Compose
│
├── Web
├── API
├── Services
├── PostgreSQL
└── RabbitMQ
Trustroop is more than a URL review application. It is designed as a practical example of building a distributed, event-driven web platform capable of handling multiple clients and independently deployable services.
The project demonstrates experience with:
- Microservice architecture
- Event-driven systems
- Asynchronous messaging
- Monorepo architecture
- Distributed application design
- REST APIs
- Type-safe backend development
- Relational database design
- Browser extension development
- Containerized applications
- Docker-based deployment
- Scalable service boundaries
- Runtime validation
- Modern TypeScript development
Trustroop is designed to evolve into a broader web trust and digital reputation platform.
Potential areas of expansion include:
- More detailed trust scoring
- Automated URL analysis
- Reputation history
- Advanced review verification
- Company and product reputation profiles
- Browser protection features
- API access for third-party applications
- Automated threat and reputation signals
- Advanced analytics
- Additional browser integrations
Contributions, ideas, bug reports, and architectural discussions are welcome.
If you find a problem or have an idea for improving Trustroop, please open an issue or submit a pull request.
Trustroop is released under the MIT License.
See the LICENSE file for details.
Trustroop is built as a real-world engineering project to explore and demonstrate modern microservices, event-driven architecture, TypeScript, distributed systems, browser extension development, and containerized deployment.
If you are interested in working together on a similar product, distributed system, SaaS platform, or custom software solution, feel free to get in touch.
Built with TypeScript, Next.js, NestJS, RabbitMQ, PostgreSQL, Prisma, Zod, Turborepo, Docker, and a focus on scalable software architecture.