Skip to content
BranchesTags

Repository files navigation

ZOG Skill Test

A coding assessment built on the production-grade Zero One Group (ZOG) development stack. Pick the track that matches your applied role, build the assigned task using this monorepo, and document your work in docs/.

Purpose

This repository is a minimal monorepo scaffold derived from the Zero One Group Monorepo. It ships the standardized ZOG tooling, conventions, and application templates so you can complete your skill test exactly the way a real ZOG project is built.

As an applicant you will:

  1. Pick the track that matches the role you applied for: Frontend (web), Backend, Infra (DevOps), or Mobile.
  2. Generate one or more applications from the provided templates.
  3. Implement the assigned task for your track.
  4. Document your work under docs/ (see Documentation).
  5. Push your work and share your repository with the hiring team (see Submission).

Tracks at a Glance

Track Applied Role Template Domains
Frontend Frontend Engineer Web & SPA frameworks, shared UI components
Backend Backend Engineer Go, Python, headless CMS
Infra (DevOps) Infrastructure / DevOps Engineer IaC, CI/CD, observability, databases, proxies
Mobile Mobile Engineer Cross-platform mobile

Tech Stack

  • Orchestration: moon — task runner, project graph, and template generator.
  • Node toolchain: Node.js 24, pnpm 11.
  • Go toolchain: Go 1.27.
  • Python toolchain: Python 3.14 with uv.
  • Formatting / Linting: Oxc (oxfmt, oxlint).
  • Local services: Docker Compose — PostgreSQL, Mailpit, MinIO, ClickHouse, Redis, and OpenTelemetry instrumentation.
  • VCS: Git with conventional commits enforced via moon hooks.

Prerequisites

The tools below are required. How to install and configure them is intentionally left for you to discover — figuring out the toolchain is part of the assessment.

  • moon — required to run tasks and generate projects.
  • Docker + Docker Compose — for local databases and backing services.
  • Go 1.27 — for Go templates.
  • Node 24 + pnpm 11 — for Node/TypeScript templates.
  • uv (Python 3.14) — for Python/FastAPI templates.

Once moon is running, it provisions the language toolchains (Go, Node, Python/uv) automatically on first use — you mainly need to get moon itself working. How to install moon is intentionally left for you to discover.

Quick Start

# 1. Fork this repository, then clone your fork
git clone <your-fork-url>
cd <repository-directory>   # the cloned folder name (matches the repo/fork name)

# 2. Install workspace dependencies
pnpm install

# 3. (Optional) Start local backing services — Postgres, Mailpit, instrumentation
pnpm compose:up

# 4. Generate the application(s) for your track
moon generate <template>        # use the template that fits your track
# follow the interactive prompts

# 5. Configure the environment
cp apps/<your-app>/.env.example apps/<your-app>/.env
# edit .env as needed

# 6. Run the project
moon run :dev                      # start all dev servers
moon run <project_id>:dev          # or start a single project

Generating from a template

Run moon generate <template-name>, where <template-name> is any template from the Available Templates list (or run moon templates to list them). Pick the template that fits your task.

The full list of templates is in Available Templates. Templates are fetched from oss.zero-one-group.com, so the first generation needs network access.

Local development services

pnpm compose:up        # start Postgres, Mailpit, and instrumentation
pnpm compose:down      # stop services
pnpm compose:cleanup   # remove service data and volumes

Uncomment additional stacks (minio, clickhouse, redis) in compose.yaml if your task requires them.

Project Structure

.
├── apps/                 # Application projects (generated from templates)
├── packages/             # Shared libraries (e.g. shared-ui)
├── infra/                # Infrastructure projects (generated from templates)
├── docker/               # Docker Compose stacks and single-service configs
│   └── _stacks_/         # Compose fragments included by compose.yaml
├── docs/                 # YOUR documentation deliverable (see Documentation)
├── scripts/              # Utility scripts (e.g. install_mockery.sh)
├── .moon/                # moon workspace, toolchain, and task configuration
├── compose.yaml          # Local development services
├── pnpm-workspace.yaml   # pnpm workspace globs and dependency catalog
└── package.json          # Root scripts (lint, format, compose, cleanup)

apps/, packages/, and infra/ start empty. Populate them with moon generate.

Available Commands

moon

Command Description
moon run :dev Start development servers for all projects
moon run :build Build all projects
moon run :test Run tests across all projects
moon run :lint Lint all projects
moon run :format Format all projects
moon check --all Run all checks (lint, typecheck, test)
moon generate <tpl> Scaffold a new project from a template
moon <id>:<task> Run a specific task for a project
moon project-graph Visualize the project dependency graph
moon :update-deps Update dependencies across projects

Run moon help, or see https://moonrepo.dev/docs/run-task for details.

pnpm / root scripts

Command Description
pnpm install Install workspace dependencies
pnpm lint Lint all projects via moon
pnpm format Format the workspace with oxfmt
pnpm typecheck Type-check all projects
pnpm compose:up Start local dev services
pnpm compose:down Stop local dev services
pnpm compose:cleanup Remove local dev service data
pnpm update-deps Update all dependencies
pnpm cleanup Clean dependencies / cache / build artifacts

Available Templates

Generate with moon generate <name>. You can also list all available templates with moon templates.

Source of truth: templates.json — 19 templates (last updated 2026-08-25). The list below mirrors that file exactly.

Frontend

  • astro — Astro website
  • nextjs — Next.js application
  • react-app — React SPA (TanStack)
  • tanstack-start — TanStack Start
  • shared-ui — Shared UI component library (shadcn/ui)

Backend

  • go-clean — Go application (Clean Architecture)
  • go-modular — Modular Go structure
  • fastapi-ai — FastAPI application for AI/ML
  • strapi — Strapi headless CMS
  • phoenix — Elixir Phoenix application

Mobile

  • expo — Expo (React Native) mobile application

Infrastructure & DevOps

  • ansible — Ansible playbooks and server hardening
  • gitlab-cicd — GitLab CI/CD pipeline configuration
  • load-balancer — Nginx load balancer / reverse proxy
  • monitoring — Observability stack (Prometheus, Grafana, etc.)
  • postgresql — PostgreSQL configuration
  • squidproxy — Squid egress proxy
  • swarm — Docker Swarm configuration
  • terragrunt — Terragrunt / OpenTofu infrastructure as code

Libraries

  • shared-ui — Shared UI component library (listed under Frontend)

Track Guidance

Each track has its own focus. ZOG uses Product Engineer levels (PE1–PE4); the bar rises with level. Your concrete base task and PE-level criteria live in ASSIGNMENT.md; the guidance below is general — choose the template(s) that fit your task.

Frontend

  • Generate a frontend application from one of the available frontend templates.
  • Tailwind CSS is the standard styling approach across ZOG frontend templates; use it for UI.
  • Write unit tests and end-to-end tests where applicable (moon <id>:e2e).
  • Your task: see ASSIGNMENT.md for the Frontend base task and your PE-level criteria. Implement it in the generated app and document UI decisions, state management, and API integration in docs/.

Backend

  • Generate a backend service from one of the available backend templates.
  • Use the local Docker stacks for databases / cache as needed (pnpm compose:up).
  • Follow the chosen template's architecture and write tests. Document the API contract, data model, and environment configuration in docs/.
  • Your task: see ASSIGNMENT.md for the Backend base task and your PE-level criteria. Implement it in the generated service and document it in docs/.

Infra (DevOps)

  • Generate infrastructure projects from the available infrastructure templates.
  • Keep infrastructure as code reproducible and documented. Describe the target topology, provisioning steps, and how to run/verify it in docs/.
  • Your task: see ASSIGNMENT.md for the Infra base task and your PE-level criteria. Implement it in the generated project(s) and document it in docs/.

Mobile

  • Generate the mobile application from the available mobile template.
  • Document navigation, state management, native modules, and how to run it on a simulator/device in docs/.
  • Your task: see ASSIGNMENT.md for the Mobile base task and your PE-level criteria. Implement it in the generated app and document it in docs/.

Documentation

You must document your work under docs/. Reviewers read docs/ first to understand your approach, decisions, and how to run your solution.

Create docs/README.md as the entry point and structure it as:

  1. Overview — what you built and your track/role.
  2. Setup & Run — exact steps to install, configure (.env), and run your project(s).
  3. Architecture & Decisions — key design choices, patterns used, and trade-offs.
  4. Task Breakdown — how each part of the assignment maps to the code, with file references.
  5. Testing — how to run unit/E2E tests and what is covered.
  6. Appendix — environment variables, useful commands, references.

The docs/ folder is intentionally left empty — you must author docs/README.md (and any supporting files) yourself, from scratch. Keep it concise but complete; link to code rather than copying it. This is part of the evaluation of your documentation ability.

Conventions

  • Commits: Conventional Commits are enforced by a commit-msg hook (see .moon/workspace.yml). Allowed types: feat, fix, chore, docs, style, refactor, perf, test, build, ci, revert. Format: <type>(<scope>): <description>.
  • Branching: Create a branch named after your track, e.g. feat/frontend-<your-name> or feat/backend-<your-name>.
  • Formatting & Linting: Run pnpm format and pnpm lint (or moon :format / moon :lint) before committing. Hooks run on pre-commit.
  • Namespaces: If you fork or rename the project, replace the myorg namespace and example.com references consistently across the codebase.

Tips for Success

  • Read the generated template's own README first — each template ships with best-practice defaults.
  • Run moon check --all before submitting; CI runs the same checks.
  • Keep changes scoped to your track; do not rewrite unrelated scaffolding.
  • Document as you go — docs/ is part of the evaluation.
  • Use moon project-graph to understand dependencies between projects.

Submission

  1. Push your work to your forked repository.
  2. Share your repository with the hiring team, or send a repository invitation to the hiring team.
  3. Ensure docs/README.md is complete and the project builds and passes checks.

Learn More

About

A coding assessment built on the production-grade Zero One Group (ZOG) development stack, designed to assess real-world coding skills.

Resources

Readme
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Contributors

Languages