# YoloCorp FAQ: Frequently Asked Questions

## General Questions

### What is YoloCorp?

YoloCorp is a backend engineering practice platform where you build complete systems with persistent data, evolving requirements, and a corporate satire storyline. Unlike algorithm-focused platforms, YoloCorp has you design APIs, manage databases, handle Docker deployments, and maintain systems over time.

Think: LeetCode for system design and backend engineering, with a story.

### How is YoloCorp different from LeetCode, HackerRank, or CodeWars?

**LeetCode/HackerRank/CodeWars** focus on algorithms and isolated coding problems. Great for interview prep.

**YoloCorp** focuses on building complete backend systems with:
- Multi-episode projects with persistent data
- Full architectural freedom (any language, framework, database)
- Docker-based deployment workflow
- Evolving requirements that force migrations and refactoring
- Real production engineering skills

See detailed comparisons:
- [YoloCorp vs LeetCode](/seo/vs-leetcode)
- [YoloCorp vs HackerRank](/seo/vs-hackerrank)
- [YoloCorp vs CodeWars](/seo/vs-codewars)

### Who is YoloCorp for?

**Perfect for**:
- Junior backend developers needing real-world practice
- Frontend developers transitioning to backend
- Bootcamp grads bridging the experience gap
- Engineers preparing for system design interviews
- Anyone wanting to [learn Docker and DevOps](/seo/learn-docker-devops)
- Developers building [portfolio projects](/seo/portfolio-projects)

**Also great for**:
- Self-taught developers
- CS students wanting practical experience
- Engineers wanting [database migration practice](/seo/database-migration-practice)

### Is YoloCorp free?

Yes, YoloCorp is free to use. [Download the CLI](/downloads) and start practicing.

### Do I need to create an account?

Yes, to track your progress and unlock episodes. Sign up with GitHub OAuth when you run the CLI.

## Getting Started

### How do I start?

1. [Download the CLI](/downloads) for your platform (Mac, Linux, Windows WSL)
2. Run `yolo enroll` to choose and enroll in a project
3. Implement the client interface in TypeScript
4. Build your backend (any language, any architecture)
5. Run `yolo deploy` to test
6. Pass tests to unlock the next episode

See our [full documentation](/doc) for detailed flow.

### What do I need installed?

**Required**:
- Docker (for running your backend and tests)
- Node.js (for the TypeScript client)
- The YoloCorp CLI

**Your choice**:
- Any programming language for your backend
- Any databases or services you want to use
- Your preferred code editor

### Do I need to know Docker?

Basic Docker knowledge helps, but YoloCorp is actually a great way to [learn Docker and DevOps](/seo/learn-docker-devops). You'll write Dockerfiles and Docker Compose configs as you go.

Start simple (single-service setup) and add complexity over time.

### What programming languages can I use?

**Any language** for your backend: Node.js, Python, Go, Rust, Java, C#, Ruby, PHP, Elixir - whatever you prefer.

The client interface is TypeScript (provided by the CLI), but your backend can be anything that runs in Docker.

### What if I've never built a backend before?

Start with a simple tech stack you're comfortable with:
- Use Node.js/Express if you know JavaScript
- Use Python/Flask if you know Python
- Use Go if you're learning Go

YoloCorp provides the requirements; you choose your implementation. Episodes start simple and build complexity gradually.

## How It Works

### How do episodes work?

Each project is divided into sequential episodes:

**Episode 1**: Basic requirements, build your initial system
**Episode 2-9**: New requirements added, must evolve your system
**Episode 10**: Final challenge incorporating everything

Each episode:
1. Downloads new client interface and tests
2. You implement the interface
3. You update your backend as needed
4. Tests validate your implementation
5. Pass = unlock next episode

### What happens to my data between episodes?

**Data persists!** This is a core feature.

Your database volumes are saved between episodes. When episode 5 requires a new feature, you must migrate your episode 1-4 data to support it.

This simulates real production engineering where you can't "just start over."

### Can I see the tests?

Tests are downloaded when you run `yolo deploy`. They're in your project directory.

Tests are black-box integration tests - they exercise your system through the client interface without caring about your implementation details.

### How are projects tested?

1. Docker Compose starts your backend services
2. Client code runs in a separate container
3. Tests execute, calling your backend through your client implementation
4. Tests verify behavior and data persistence
5. Results reported as pass/fail

Everything runs locally in Docker. No remote execution.

### Can I use any database?

**Yes!** Use whatever fits the requirements:
- SQL: Postgres, MySQL, SQLite
- NoSQL: MongoDB, CouchDB, Redis
- Files, in-memory with snapshots, whatever

You define your storage strategy in `user-compose.yml`.

### Can I use any framework?

**Yes!** REST, GraphQL, RPC, gRPC - your choice.

YoloCorp only tests the client interface behavior. How you implement it (framework, patterns, architecture) is entirely up to you.

### Can I build microservices?

**Absolutely!** You can define multiple services in `user-compose.yml`:
- Separate API gateway and business logic services
- Dedicated database per service
- Message queues for async processing
- Any architecture you want

As long as your client can communicate with your services via the Docker network `yolo-network`.

## Difficulty & Time

### How hard is YoloCorp?

**Episode 1**: Manageable for anyone with basic programming skills
**Episodes 3-5**: Requires understanding of APIs and databases
**Episodes 7-10**: Real engineering challenges with migrations and complex requirements

Difficulty grows gradually. Early episodes teach foundational concepts.

### How long does an episode take?

**Varies widely**:
- Episode 1: 2-6 hours (setting up architecture)
- Middle episodes: 1-4 hours (implementing features)
- Complex episodes: 4-8+ hours (migrations, refactoring)

Depends on your experience and architectural choices.

### What if I get stuck?

**Debugging strategies**:
- Check Docker logs: `docker logs <service-name>`
- Read test output carefully
- Verify your client implementation
- Check Docker networking
- Review the requirements in `toImplement.ts`

**No official support**, but problem-solving is part of the learning. Real production debugging.

### Can I start over if I make bad decisions?

**Yes!** You can:
- Abandon and re-enroll in the same project
- Try different architectures
- Learn from mistakes

This is how you discover what works and what doesn't.

### Can I skip episodes?

**No.** Episodes must be completed sequentially because:
- Later episodes build on earlier data
- Requirements evolve progressively
- You must maintain the system you built

This simulates real systems that evolve over time.

## Technical Details

### Where does my code run?

**Locally** on your machine in Docker containers:
- Your backend runs in containers you define
- The client runs in a Node container (generated by CLI)
- Tests execute inside the client container
- Everything isolated in Docker Compose

No remote servers. You have full control.

### How do services communicate?

Via Docker network `yolo-network`:
- Your backend must be on this network
- Client reaches your backend using service names as hostnames
- All standard Docker Compose networking applies

Example: If your service is named `backend`, the client reaches it at `http://backend:3000`.

### What's the backend healthcheck for?

The client waits for your backend to be healthy before running tests. This ensures:
- Migrations have completed
- Database is ready
- Services are initialized

Implement a `/health` endpoint that returns 200 when ready.

### Can I use environment variables?

**Yes!** Define them in `user-compose.yml`:

```yaml
services:
  backend:
    environment:
      DATABASE_URL: postgres://db:5432/app
      API_KEY: your-key
```

### What happens to my Docker volumes?

Volumes are saved in `.snapshots/` directory after passing each episode. These are restored when you continue.

**Don't delete `.snapshots/`** - it contains your persistent data!

## Progress & Platform

### Is my progress saved?

**Yes**, on YoloCorp servers. When you complete episodes:
- Local `.snapshots/` saved to disk
- Server records your latest completed episode
- Can continue from any machine by running `yolo deploy`

### Can I work offline?

**Partially**:
- Episodes must be downloaded (requires internet)
- Development can be done offline
- `yolo deploy` requires internet to submit progress

### Can I share my projects?

**Yes!** Your code is yours:
- Push to GitHub for portfolio
- Share Docker setup
- Write blog posts about architecture
- Use in job interviews

Many developers showcase YoloCorp projects as [portfolio pieces](/seo/portfolio-projects).

### Can I work on multiple projects?

**Yes!** Each project lives in its own directory. You can have multiple projects in progress.

### What if a new episode is released while I'm working?

Run `yolo check-episode` to download the latest episode when available.

If you're on the latest published episode, YoloCorp will tell you when the next one releases.

## Use Cases

### Is YoloCorp good for interview prep?

**Yes, for system design interviews!** See [Backend Interview Prep](/seo/backend-interview-prep).

You'll practice:
- Designing complete systems
- Making architectural decisions
- Explaining trade-offs
- Handling evolving requirements

### Can junior developers use YoloCorp?

**Absolutely!** See [Junior Backend Developer Practice](/seo/junior-backend-developer-practice).

YoloCorp bridges the gap between tutorials and real production work. Start simple, grow complexity.

### I'm a frontend developer. Can I learn backend?

**Yes!** See [Frontend to Backend Transition](/seo/frontend-to-backend-transition).

You already understand APIs from the client side. YoloCorp teaches the server side with progressive difficulty.

### Does this help me learn system design?

**Very much!** See [Learn System Design](/seo/learn-system-design).

You'll make real architectural decisions, experience trade-offs, and build systems from requirements - not just read about them.

## Still Have Questions?

Check our [full documentation](/doc) for detailed technical information.

Ready to start? [Download the CLI](/downloads) and begin your first project.