Productify

Appearance

Manager ​

The Manager is the core web UI and API component of the Productify Framework, designed for managing SaaS productization, multi-tenant configuration, and operational workflows.

Overview ​

Manager provides a comprehensive platform for building and managing multi-tenant SaaS applications with built-in authentication, configuration management, and operational automation.

Key Features ​

Multi-tenant SaaS Management ​

Tenants are customer organizations with complete data separation at the database level. Applications are defined once per project and enabled per tenant — one deployment serves every tenant. See Multi-tenancy.

Application & Project Administration ​

Manage applications, environments, endpoints, and projects with hierarchical organization and access control. Deployment specs (ports, health checks, resources, scaling) live on the application's deployments and drive the rendered Nomad jobs and proxy vhosts.

User & Role Management ​

  • End Users: Membership-based access over a fixed role vocabulary (readonly, normal, tester, developer, maintainer, owner) — roles are built-in enums, not project-defined
  • Self-Service: Tenant admins invite members, assign roles, and manage their own organization — no operator required; every change is audit-logged
  • Machine Users: Automated service-to-service authentication with dual auth modes (Bearer/Basic)
  • Personal Access Tokens (PAT): API access with PBKDF2-SHA256 hashing (OWASP 2023 parameters); minted manually in the Manager UI and pasted into pfy login --token (there is no browser login — see Known Issues)

GraphQL API ​

Type-safe API powered by gqlgen and Ent ORM with automatic schema generation from database models.

Settings & Configuration ​

  • Frontend Settings: Modules, themes, locales, and key-value pairs
  • Backend Settings: Module configurations and environment-specific settings
  • Multi-layer Inheritance: Project → Tenant → Tenant × Application cascading — the same app can look different to every tenant
  • Dual Editors: GUI editor for structured editing, JSON editor for advanced use

Trigger System ​

Event-driven automation with cron execution, backend registration (kept fresh by re-registering), and callback dispatching. A trigger fires once per deployment (one delivery per registered backend); the backend fans out over its enabled tenants itself, listing them via GET /api/machine/application/:id/tenants. Registration is per (application, environment) via an environment-scoped machine user. See Backend Registration.

Extensible Architecture ​

Modular design supporting plugins, custom modules, and integration with external services.

Technology Stack ​

Backend ​

  • Language: Go 1.25+
  • Database: PostgreSQL with Ent ORM
  • API: GraphQL (gqlgen) + REST endpoints
  • Web Framework: Gin
  • Authentication: PocketID (OIDC) via the proxy, PBKDF2-hashed tokens (PATs and machine users), Bearer/Basic auth

Frontend ​

  • Framework: Vue.js 3 with Composition API
  • UI Library: Quasar Framework
  • State Management: Pinia
  • GraphQL Client: urql with caching
  • i18n: @byjohann/vue-i18n
  • Build Tool: Vite

Architecture ​

┌─────────────────────────────────────────────────┐
│                   Frontend (Vue)                │
│  ┌──────────┐  ┌─────────┐  ┌────────────────┐  │
│  │ Quasar   │  │ urql    │  │ Pinia Stores   │  │
│  │ Component│  │ GraphQL │  │ (State)        │  │
│  └──────────┘  └─────────┘  └────────────────┘  │
└─────────────────────────────────────────────────┘
                      │
                      │ GraphQL / REST
                      ▼
┌─────────────────────────────────────────────────┐
│              Manager Backend (Go)               │
│  ┌──────────┐  ┌─────────┐  ┌────────────────┐  │
│  │ GraphQL  │  │ REST    │  │ Trigger        │  │
│  │ Resolver │  │ Handler │  │ Executor       │  │
│  └──────────┘  └─────────┘  └────────────────┘  │
│  ┌──────────────────────────────────────────┐   │
│  │     Ent ORM (Schema & Queries)           │   │
│  └──────────────────────────────────────────┘   │
└─────────────────────────────────────────────────┘
                      │
                      ▼
              ┌──────────────┐
              │  PostgreSQL  │
              └──────────────┘

Use Cases ​

SaaS Platform Management ​

Manage multiple tenants, applications, and users from a single unified interface.

Multi-tenant Configuration ​

Define settings at project, tenant, or application level with inheritance cascading.

Backend Integration ​

Register backend services for trigger execution and event-driven workflows.

Enterprise Service Bus (ESB) ​

Secure API gateway with transformation, authentication, and configurable audit logging. Learn more

Pilet API ​

Microfrontend module management with package storage, versioning, and dynamic loading. Learn more

API Gateway ​

Expose GraphQL and REST APIs for external integrations and custom applications.

Next Steps ​

  1. Get Started: Follow the Quick Start Guide to run Manager locally
  2. Learn Concepts: Explore Trigger System and Multi-tenancy
  3. Configure: Review Configuration Options for your environment
  4. Deploy: Check out Deployment Options for production

Support ​