---
title: 🏗 Architecture of Palmr.
---

## 🔍 Overview

Understanding the architecture of Palmr. is crucial for both deploying and scaling the application. Below is a diagram illustrating the main components:

![Palmr Banner](/assets/v2/general/architecture.png)

## 🛠 Technologies Used

Each component in the Palmr. architecture plays a vital role in ensuring reliability, performance, and scalability. The stack is built with simplicity, performance, and flexibility in mind, everything is self-hosted, developer-friendly, and designed to scale without adding unnecessary complexity.

### 💾 PostgreSQL

Palmr. uses **PostgreSQL** as the primary database solution. It's a powerful, open-source relational database that’s trusted by developers around the world. PostgreSQL is fully ACID-compliant, which means it handles transactions safely and reliably. It’s perfect for storing structured data like user accounts, file metadata, transfer logs, and anything else that requires consistency. With advanced features like full-text search, custom data types (like JSONB), and strong indexing capabilities, PostgreSQL gives us the tools to scale efficiently without giving up query performance or flexibility.

- Provides reliable and secure data storage, ensuring consistency and high performance for all database operations.
- Powerful indexing, query optimization, and support for complex data types.
- Ideal for handling large amounts of metadata and transactional data in a predictable and scalable way.

### 🎨 Next.js 15 + React + TypeScript

The frontend of Palmr. is built using **Next.js 15**, along with **React** and **TypeScript**, forming a modern stack that’s easy to maintain and super fast for end users. Next.js 15 brings server components, server actions, and a new app router system that makes rendering dynamic content incredibly efficient. This allows us to load only what’s needed, when it’s needed which makes the app feel snappy even under load. React provides a clean, component-based structure that makes it easy to break the UI into reusable pieces, and TypeScript helps prevent bugs before they even happen by enforcing static typing and better code navigation. Whether it's SSR, static pages, or dynamic user interactions, this trio handles it all seamlessly.

- **React** enables the creation of a dynamic and responsive user interface with a component-based architecture.
- **TypeScript** adds static typing, enhancing code quality and reducing runtime errors.
- **Next.js 15** handles routing, server-side rendering, and server components for performance at scale.

### 📦 MinIO

Palmr. uses **MinIO** for object storage. MinIO is a lightweight, high-performance, S3-compatible storage solution that makes file handling simple and scalable. Every file uploaded to Palmr. Whether it's a personal file transfer or a shared asset is stored in MinIO. It’s built to handle huge amounts of data and can be deployed locally, on-premise, or in the cloud. Because it speaks the same API as Amazon S3, integrating with it is straightforward and familiar to most developers. And since it’s self-hosted, we have full control over performance, redundancy, and security.

- Supports high-throughput file storage and retrieval.
- Ensures data integrity and redundancy.
- Compatible with AWS S3 APIs, making integration seamless.

### ⚡ Fastify

The backend of Palmr. is powered by **Fastify**, a super-fast Node.js web framework optimized for performance and low overhead. It’s designed to handle lots of concurrent requests with minimal resource usage, which is key for scalable backend services. Fastify also has a built-in schema validation system that ensures all incoming data is properly validated before reaching business logic, which helps prevent bugs and security issues. It follows a plugin-based architecture, making it easy to keep route handlers, services, and middlewares cleanly separated and easy to extend as the project grows.

- Provides fast request handling with a lightweight core.
- Built-in schema-based validation for secure and reliable API handling.
- Supports plugin-based architecture for easy extensibility.

### 🔄 How It Works

1. **Frontend** — React + TypeScript + Next.js 15 handle the user interface and user interactions.
2. **Backend** — Fastify processes requests and communicates with the database and storage layers.
3. **Database** — PostgreSQL stores metadata and transactional data.
4. **Object Storage** — MinIO stores the actual files and ensures scalable, high-performance storage.

### 📚 Useful Links

- [PostgreSQL Documentation](https://www.postgresql.org/docs/)
- [Next.js Documentation](https://nextjs.org/docs)
- [React Documentation](https://react.dev/)
- [TypeScript Handbook](https://www.typescriptlang.org/docs/)
- [MinIO Documentation](https://min.io/docs/minio/container/index.html)
- [Fastify Documentation](https://fastify.dev/docs/latest/)
