> For the complete documentation index, see [llms.txt](https://docs.pyck.cloud/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pyck.cloud/faq/faq-development.md).

# FAQ for Developers

Frequently asked questions about Pyck for developers

Audience: Programmer

## How is data stored in Pyck?

Pyck uses a **multi-tenant architecture** with strict tenant isolation at the database level. Each tenant operates in a fully separated data space with no cross tenant data access. Within a tenant, multiple root level repositories (warehouses) can exist.

**PostgreSQL** serves as the primary data store. **S3-compatible storage** is used for files and attachments. The movement-based data model also enables **time-travel queries**, allowing you to query inventory state at any historical point in time.

## Which database is used?

**PostgreSQL** is the primary database. **S3-compatible storage** is used as object storage for files and attachments.

## What is the technology stack?

| Component        | Technology                      |
| ---------------- | ------------------------------- |
| API              | **GraphQL** with Federation     |
| Database         | **PostgreSQL**                  |
| Event Streaming  | **NATS.io**                     |
| Workflow Engine  | **Temporal.io**                 |
| Authentication   | **OIDC/OAuth2** (e.g., Zitadel) |
| Containerization | **Docker**                      |
| Orchestration    | **Kubernetes**                  |

The logical foundation is built on these core concepts:

* **Repositories** — hierarchical containers for anything that can hold goods
* **Movements** — every inventory change as an executable instruction with full audit trail
* **Movement Collections** — ordered sequences of movements with forward-looking stock validation
* **DataTypes** — JSON Schema-based validation for flexible custom data

## What are the Pyck framework building blocks?

The Pyck framework consists of three main components: the **Core** (backend services), the **Web App**, and the **Mobile App**.

**Core:** Backend services consisting of a **GraphQL API** (with Federation), **event streaming** (NATS.io), and **workflow orchestration** (Temporal.io).

**Web App:** Browser-based interface for managing warehouse operations, configuration, and monitoring.

**Mobile App:** Native mobile application for on-the-floor warehouse tasks such as picking, receiving, and inventory management.

## Do data types need to be defined from scratch?

No. Pyck comes with predefined Entities (e.g., items, orders, customers, suppliers) that cover common warehouse concepts out of the box.

**DataTypes** are specializations of these Entities —— you define them yourself using an editor to add custom fields tailored to your business needs. Every Entity has a data field that is automatically validated against the custom JSON schema you can define, so your custom data is structured and type-safe without any backend code or database changes.

## How are processes defined and modeled?

Pyck uses Temporal.io as its workflow engine. Logistics processes are defined as Temporal workflows — primarily in Go, as this is the Pyck SDK that is currently available, though Temporal itself supports multiple languages. The Pyck Go SDK is optional and serves as a convenience layer; workflows can also be implemented without it.

For Pyck-specific workflow concepts, see:

* [Workflows (Concepts)](/basics/workflows.md)
* [Workflows (Development)](/development/workflows.md)

For details on authoring Temporal workflows, refer to the [Temporal Go SDK documentation](https://docs.temporal.io/develop/go).

## What programming language is the code written in?

**Go.** All backend services are written in Go.

Maintainability is supported by:

* **API-first design** — the GraphQL schema drives implementation
* **Microservice architecture** — clear separation of concerns

## How do concurrent processes affect each other?

Pyck is designed to handle concurrent API requests without conflicts. Database transactions and stock validations ensure operational consistency, even under concurrent load.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.pyck.cloud/faq/faq-development.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.