Unified Architecture Across Backend, Frontend, and Infrastructure
The Cante Framework promotes architectural clarity by aligning all application layers under a common structure. Backend logic, frontend UIs, and operational components are developed within a single ecosystem. This reduces integration friction, fosters cross-functional collaboration, and streamlines the development lifecycle.
Technology Stack
At the core of cante framework is a full-featured and tightly integrated technology stack, combining proven open-source tools and modern development paradigms.
This stack ensures a coherent architecture where all components are optimized to work together from day one.
PostgreSQL serves as the core database layer. Known for its strong adherence to SQL standards, PostgreSQL offers full ACID compliance, transactional integrity, and exceptional performance under concurrent workloads.
Hasura builds a dynamic, real-time GraphQL API directly on top of the PostgreSQL schema. It allows frontend and backend teams to consume and mutate data without manually writing boilerplate CRUD code.
Backends are written in either Elixir (for concurrency and reliability) or Python (for flexibility and wide library support).
Both languages are fully containerized and can be integrated into the same environment, offering hybrid backend architectures when appropriate.
A centralized JavaScript monorepo provides a unified frontend structure, simplifying development and reuse across applications. The monorepo setup supports versioning, dependency isolation, and atomic deployments.
An integrated OAuth-based authentication system handles user and access management securely and extensibly. The system is compatible with Hasura’s permission model and backend services via bearer tokens and scopes. This ensures consistent access control across APIs, UIs, and background jobs.
The Hive Registry serves as a central registry for service definitions, schemas, and configuration metadata – ensuring that all components can discover and interact with each other in a consistent and versioned manner. It plays a key role in reducing integration risks by enforcing consistent interfaces and enabling early detection of breaking changes.
Modular Docker-Based Service Architecture
Every component of the system is containerized independently using Docker, which ensures clean separation of concerns and reproducibility. Services can be versioned, replaced, or scaled without affecting the rest of the system. This modularity simplifies upgrades, testing, and parallel development across teams.
Each component comes with its own development container, into which developers can directly connect using Visual Studio Code. These dev containers are not isolated sandboxes but act as drop-in replacements for the corresponding production services within the running system.
This approach brings several benefits:
• Developers work in the same environment as production, reducing bugs caused by discrepancies
• Real-time development, debugging, and testing are possible without manual configuration
• Services interact exactly as they would in the live system – ensuring true full-stack development
Native Integration with Visual Studio Code
By integrating with VS Code’s Remote Container functionality, the framework enables developers to open, edit, and debug code within the exact container where it runs. This eliminates environment mismatches, simplifies debugging, and enhances developer productivity through native tool support.
Infrastructure as Code with Ansible
