Real environments

The services the job runs on. Described in one file.

Seven languages at pinned versions, PostgreSQL and Valkey inside the sandbox, and multi-service apps defined in one kendor.yaml. What the candidate runs is what the grader runs.

Request access See pricing

Orders dashboard41:08

Processes

Sandboxrunningdocker

api:8000

web:5173

Database

New process

Databases

PostgreSQL18

postgresql://kendor@127.0.0.1:5432/app

Apps read DATABASE_URL, already set. Run psql in a terminal to look inside.

All variables (13)

Valkey9

redis://127.0.0.1:6379

Apps read REDIS_URL, already set. Run redis-cli in a terminal to look inside.

All variables (6)

Set in every process: the app, terminals and tests. Not reachable from outside the sandbox. Every grade starts with an empty database.

kendor.yamlmain.pyApp.tsx

1version: 1

2runtime:

3 type: python

4 version: "3.12"

5toolchains:

6 - type: node

7 version: "22"

8databases:

9 - type: postgres

10 version: "18"

11 init: db/seed.sql

12 - type: valkey

13 version: "9"

14services:

15 api:

16 workDir: api

17 install:

18 commands: [pip install -r requirements.txt]

19 dev:

20 command: uvicorn app.main:app --port 8000

21 port: 8000

22 web:

23 workDir: web

24 install:

25 commands: [npm ci]

26 dev:

27 command: npm run dev

28 port: 5173

29preview:

30 service: web

31routing:

32 - { path: /api, service: api }

33 - { path: /, service: web }

Ln 33, Col 31Spaces: 2UTF-8YAML

Seven languages, pinned. Several at once.

Each challenge pins its language versions in kendor.yaml, so a screen written in March grades the same in October. Add other languages beside the main one, the way a real backend and frontend sit together.

Versions offered today

Node.js / TypeScript22
Python3.12
Go1.27 · 1.26
Java21
Rust1.98
C++ (Clang)23
PHP8.4 · 8.3

Runtime & servicesconfig validFormRaw YAML

Languages

Java21Main

Node.js

PHP

Python

Go1.27

Rust

C++23

The main language plus any others this project needs. Each one gets its compiler, tools and editor support in the sandbox and when grading.

Databases inside the sandbox, clean for every grade.

PostgreSQL and Valkey (Redis-compatible) run next to the candidate's code, seeded from your SQL. Every grade starts from an empty database and your seed, so nothing a candidate left behind affects the result.

Apps read DATABASE_URL and REDIS_URL, already set in every process
Started before installs, in the editor and when grading

Databases

PostgreSQL18

postgresql://kendor@127.0.0.1:5432/app

Apps read DATABASE_URL, already set. Run psql in a terminal to look inside.

All variables (13)

Valkey9

redis://127.0.0.1:6379

Apps read REDIS_URL, already set. Run redis-cli in a terminal to look inside.

All variables (6)

Set in every process: the app, terminals and tests. Not reachable from outside the sandbox. Every grade starts with an empty database.

Terminalrunner@sandbox:/workspace

$ psql -c "select title, done from todos"

title | done

--------------------------+------

Read the brief | t

Write the first endpoint | f

(2 rows)

$ redis-cli ping

PONG

$ node --test

✓ lists the seeded todos (41ms)

✓ creates a todo (18ms)

✓ rejects a todo without a title (6ms)

✓ caches the list and refreshes it after a new todo (23ms)

Candidates can extend it. The foundations stay yours.

A candidate can add a service or a route if their solution needs one, a worker for a queue, say. The runtime, the databases, the sandbox and the grading stay exactly as the author set them.

Install, services, preview and routing apply after a sandbox restart
Tests a candidate writes into kendor.yaml are dropped; grading runs yours

Todo API27:45

kendor.yamlworker.js

kendor.yaml changedYour services, install, preview and routing apply after a restart. The language, databases and sandbox stay as the challenge set them.

Restart sandbox

11services:

12 app:

13 install:

14 commands:

15 - npm ci

16 dev:

17 command: node --watch src/server.js

18 port: 3000

19 test:

20 command: node --test

21 worker:

22 dev:

23 command: node src/worker.js

24preview:

25 service: app

Docker, Compose and Kubernetes for platform roles.

For platform and DevOps hiring, the sandbox can run its own Docker daemon with Docker Compose, or a single-node k3s cluster with kubectl and helm. These are reviewed or live challenges: a person reads the work, and Kendor doesn't auto-grade it.

Enterprise

Containers

DockerKubernetes (k3s)

Terminalrunner@sandbox:/workspaceReviewed, not auto-graded

$ docker build -t orders-api:dev app

=> naming to docker.io/library/orders-api:dev

$ helm install orders ./chart

NAME: orders

STATUS: deployed

REVISION: 1

$ kubectl get pods

NAME READY STATUS RESTARTS

orders-api-6d8f7c9b5d-2xkqp 1/1 Running 0

orders-api-6d8f7c9b5d-9vtmh 1/1 Running 0

How it works

One file describes the whole environment.

Write or import kendor.yaml
Languages, databases, services, install steps, routing and preview, in a form or as raw YAML. Repo import fills in a first version from the project's files.
Try it as a candidate
Open the sandbox in the challenge editor, watch the services come up and run the tests.
Publish the screen
Every candidate boots from the setup saved with the challenge, at the versions it pins.

Questions

Is Valkey a drop-in for Redis?

For screens, yes. Valkey speaks the Redis protocol, so standard Redis clients connect to it unchanged, and REDIS_URL is already set.

Can a candidate change the language version?

No. The runtime, other languages, databases and sandbox belong to the author. Candidates can change how their own code installs, starts and is routed — add a service, a worker, a route — and grading always runs the author's tests.

Are Docker and Kubernetes challenges graded?

Not automatically. They run as reviewed or live challenges on the Enterprise plan; reviewers look at the work and record a verdict.

Is each candidate isolated?

Yes. Each one runs in their own locked-down container on dedicated sandbox servers, with internet for package installs but no access to Kendor's network or to other candidates. Grading re-runs with the network cut.

Which frameworks have starters?

React with Vite, Express with PostgreSQL and Valkey, Laravel, Flask, FastAPI, Go net/http, Spring Boot, Rust axum, a C++ CMake project, a mixed Java + Go + C++ service set, and single-file starters for every language.

More of Kendor

All features

Run your next screen on Kendor. Read what the code says.

Kendor works with engineering teams in the EU, the UK and the US. Tell us what you're hiring for and we'll set up your organization with you.