Completed
Build a Task Management REST API - Week of 19 Oct 2026
This challenge has ended. You can still review the details below.
Explore the latest challenge for this roleDesign and implement a RESTful task management API with persistent storage, user authentication, and comprehensive test coverage. You may use Python, JavaScript/TypeScript, Java, C#, or Go. Your submission will be evaluated through repository review when the challenge window closes, followed by a mandatory in-app conversation to verify your understanding.
Software Engineer
Solo only.
Share this challenge

The Challenge Brief
Problem definition
You are building a backend service for a small team collaboration tool. The system must store tasks with title, description, status (todo, in-progress, done), priority (low, medium, high), and assignment to users. The API must support CRUD operations on tasks, list filtering by status and priority, and basic user management. Inputs are HTTP requests with JSON payloads; outputs are JSON responses with appropriate status codes. The service must persist data to a relational database, validate input, and reject unauthorized requests. Every line under Success criteria is in scope for this challenge. Build the core scope in Task brief. Topic coverage uses repository evidence where available and the comprehension conversation; it does not require a separate feature for every topic.
Task brief
Implement a task management REST API with the following mandatory behaviors: (1) create, read, update, and delete tasks via HTTP endpoints; (2) filter tasks by status and priority; (3) store and retrieve data from a relational database; (4) validate all inputs and return appropriate error responses; (5) implement basic token-based authentication to protect endpoints; (6) write unit and integration tests covering core workflows; (7) containerize the application with Docker; (8) use version control with meaningful commits throughout development. This challenge integrates Version Control, Programming Fundamentals, Object-oriented Programming, Data Structures & Algorithms, Database Fundamentals, API Development Fundamentals, Security Fundamentals, Software Design Principles, Testing Fundamentals, Debugging & Troubleshooting, AI Assisted Software Development, and Containerization (Docker). Estimated effort: 6-8 hours with AI assistance.
Version Control
Version Control is the practice of tracking and managing changes to code over time using a distributed system like Git. In this task, you will initialize a repository for the backend service, commit your code changes with clear messages, create feature branches for isolated work, merge branches back to main, resolve any conflicts that arise, and use pull requests to review and integrate changes. This ensures the team can collaborate safely, audit changes, and recover from mistakes.
Programming Fundamentals
Programming Fundamentals underpins the backend service by requiring you to write clear, correct code that declares variables, applies operators and control flow to validate input, defines functions to handle API requests, uses collections to store and filter tasks, and handles exceptions when database or HTTP operations fail. You will demonstrate these skills through a working REST API with CRUD endpoints, input validation, and error responses.
Object-oriented Programming
Design and implement the core task and user entities for the backend service using object-oriented programming principles. Build classes to represent tasks and users with proper initialization, encapsulation of state, and clear separation of concerns. Structure the domain model so that it can be extended with inheritance and polymorphism as the API grows, and ensure the codebase is testable and maintainable through composition and well-defined interfaces.
Data Structures & Algorithms
Implement Data Structures & Algorithms to build the core backend service for task management. You will use native arrays or lists to store tasks, hash tables or dictionaries to index tasks by ID for fast lookup, sorting to order tasks by priority or status, and searching to filter tasks by status and priority. These data structures and algorithms form the foundation of the API and must support CRUD operations, filtering, and reliable performance.
Database Fundamentals
Database Fundamentals teaches you to design and query relational databases for the task collaboration API. You will create a schema to store tasks and users, write SQL queries to retrieve and filter data, and implement CRUD operations backed by a relational database. This skill ensures your backend persists data reliably and retrieves it efficiently for the API endpoints.
API Development Fundamentals
Build API Development Fundamentals by implementing a backend service for a task collaboration tool. You will design and code HTTP endpoints that handle CRUD operations on tasks, apply REST principles, validate JSON payloads, return appropriate status codes, and persist data to a relational database. The service must be testable, secure against unauthorized access, and documented so other developers can integrate it without confusion.
Security Fundamentals
Implement Security Fundamentals in the backend service by requiring user authentication via credentials, enforcing role-based access control to restrict task operations, validating all JSON input payloads, and storing passwords securely. These controls ensure only authorized users can access and modify tasks, and that malformed or malicious requests are rejected before processing.
Software Design Principles
Apply Software Design Principles to structure the backend service API so that business logic, data access, and HTTP handling are cleanly separated, code duplication is minimized, and the system remains simple and testable. Your implementation must demonstrate Separation of Concerns, DRY, KISS, SOLID Principles, and Dependency Injection so that other developers can understand, extend, and test each layer independently.
Testing Fundamentals
Testing Fundamentals requires you to write unit tests, integration tests, and test fixtures for the task management API to ensure CRUD operations, input validation, and database persistence work correctly. You will use assertions to verify API responses, mock external dependencies where needed, and demonstrate that your code behaves as specified under normal and edge-case conditions.
Debugging & Troubleshooting
Implement Debugging & Troubleshooting practices into the backend service to ensure the API behaves correctly under normal and error conditions. Use breakpoints, logging, and stack trace analysis to identify and fix bugs in CRUD operations, validation, and database persistence. Write tests that exercise error paths and verify that failures are caught early and reported clearly, so the team can integrate the service with confidence.
Ai Assisted Software Development
Build a backend API for the task collaboration tool using AI-assisted software development. You will use an AI assistant to help generate API endpoints, database models, write and debug tests, and refactor code. The goal is to deliver a working prototype with core CRUD operations, input validation, and a test suite—while documenting how you prompted the AI, validated its output, and corrected errors to meet the specification.
Containerization (Docker)
Containerize the backend task service using Docker so that the application, database, and dependencies run in isolated, reproducible containers. Package the service with a Dockerfile, build a working image, and run it with proper environment configuration and networking so that other developers can start the service with a single command without manual setup.
Language and stack
You must choose exactly one language from: Python, JavaScript/TypeScript, Java, C#, or Go. Your README must name the chosen language, list all dependencies, and provide clear run instructions (including database setup and how to start the server). Do not require a specific framework; select tools appropriate to your language. Include a Dockerfile for containerization.
Scenario
Your team uses a task board to coordinate work. Currently tasks are tracked in a shared spreadsheet, but the team needs a programmatic API so mobile and web clients can sync in real time. You are hired to build the backend service. The API must be reliable, secure, and testable so other developers can integrate it without confusion. You have one day to deliver a working prototype with core features and tests.
Deliverables
- A working REST API with endpoints for task CRUD, filtering, and user authentication, deployed in a Docker container.
- A relational database schema with migrations or initialization scripts, and sample data in the repository.
- Comprehensive unit and integration tests demonstrating core workflows, with test results documented in the README.
Success criteria
These are repository evidence checks within the core scope, not additional feature requests. One implementation or test may provide evidence for several topics. Missing implementation evidence remains unverified; explanations alone do not demonstrate implementation proficiency.
Version Control
- Repository Setup (beginner): Repository is initialized with a .gitignore file appropriate to the chosen language; initial commit is present.
- Basic Commands (beginner): Learner has used git add, git commit, and git push to save and share at least two distinct code changes (e.g., initial setup and a feature addition).
- Commits (beginner): At least three commits exist in the repository history, each with a clear, descriptive message that explains what changed and why.
- Branching (beginner): At least one feature branch (not main) is created and contains commits; branch name reflects the work (e.g., feature/task-crud or fix/validation).
- Merging (beginner): Feature branch is merged back to main via git merge or equivalent; merge commit or fast-forward is recorded in history.
- Conflict Resolution (intermediate): If a merge conflict occurs during the challenge, learner resolves it by editing the conflicted file, staging the resolution, and completing the merge; evidence is a commit message or log entry showing conflict resolution.
- Pull Requests (intermediate): If the repository platform supports pull requests (GitHub, GitLab, Bitbucket), learner creates at least one pull request from a feature branch to main, includes a description of changes, and merges it; if not supported, assess only if present.
Programming Fundamentals
- Variables & Data Types (beginner): Code declares and uses typed variables (strings for task title/description, integers for priority levels, enums or strings for status values) consistently across request handlers and database models.
- Operators (beginner): Code uses comparison operators (==, !=, <, >) and logical operators (&&, ||, !) to validate task priority, status values, and filter conditions in list endpoints.
- Expressions (beginner): Code evaluates expressions to compute task filter results, construct response payloads, and determine HTTP status codes based on operation outcome.
- Control Flow (beginner): Code uses if/else or switch statements to route requests by HTTP method, validate status transitions (e.g., reject invalid status values), and branch on authorization or validation failures.
- Functions & Methods (beginner): Code defines reusable functions to handle GET/POST/PUT/DELETE operations, validate input payloads, and query or update the database; each function has a single clear responsibility.
- Collections (intermediate): Code uses arrays or lists to store multiple tasks, implements filtering by status and priority using iteration or built-in collection methods, and returns filtered results in JSON responses.
- Exception Handling (intermediate): Code catches and handles database errors, JSON parsing errors, and validation failures; returns appropriate HTTP error responses (400, 401, 404, 500) with error messages instead of crashing.
- File Handling (beginner): If the prototype persists data to a file (e.g., JSON file or SQLite), code reads and writes data correctly; if using only in-memory or external database, this criterion is not required.
Object-oriented Programming
- Classes & Objects (beginner): Task and User classes exist in the repository with properties matching the core schema (task: title, description, status, priority, assignee; user: id, name, email) and are instantiated in at least one test or API handler.
- Constructors (beginner): Task and User classes have explicit constructors or initialization methods that accept required parameters and set instance properties; evidence visible in test setup or API request handling.
- Encapsulation (beginner): Task and User properties are not directly mutable from outside the class (private/protected fields or property accessors); at least one property is read-only or validated on assignment.
- Inheritance (intermediate): If a base class or abstract entity exists (e.g., Entity, Model, or Auditable), child classes (Task, User) inherit from it and reuse at least one method or property; if not present in core, assess only if implemented.
- Polymorphism (intermediate): If multiple entity types or handlers exist, at least one method is overridden or implemented differently in a subclass or interface implementation; if not present in core, assess only if implemented.
- Abstraction (intermediate): At least one interface or abstract class defines a contract (e.g., Repository, Validator, or Entity interface); concrete classes implement or inherit from it; if not present in core, assess only if implemented.
- Interfaces (intermediate): If interfaces or protocols are used, at least one is defined and implemented by a concrete class (e.g., IRepository, IValidator); if not present in core, assess only if implemented.
- Composition (intermediate): Task or User class uses composition by holding references to other objects (e.g., Task holds a User assignee, or a service holds a repository); the composed object is initialized and used in at least one method.
Data Structures & Algorithms
- Arrays (beginner): Repository contains task storage using a native array or list type; CRUD operations (create, read, update, delete) on tasks preserve insertion order or allow indexed access.
- Lists (beginner): Repository implements task list retrieval; working list endpoint returns all tasks in order without data loss or corruption.
- Stacks (beginner): If present in codebase, stack data structure is used for undo/redo or call stack reasoning; assess only if implemented, otherwise covered in comprehension.
- Queues (beginner): If present in codebase, queue data structure is used for task processing or request ordering; assess only if implemented, otherwise covered in comprehension.
- Hash Tables (intermediate): Repository uses hash tables or dictionaries to index tasks by ID or users by ID; verify via code inspection or test that direct key lookup completes without iteration over all entries.
- Sorting (intermediate): Repository contains code that sorts tasks by priority or status; working list endpoint returns sorted results matching the filter request (e.g., high-priority tasks first).
- Searching (intermediate): Repository contains code that filters tasks by status and priority; working filter endpoint returns only matching tasks without returning all tasks first and filtering in the client.
- Time Complexity (intermediate): Code demonstrates awareness of lookup and filter performance; hash table lookups are O(1) and filter operations avoid unnecessary full scans when indexes are available.
Database Fundamentals
- Relational Databases (beginner): Repository contains a schema definition (SQL DDL or ORM model) that defines tasks table with columns for id, title, description, status, priority, and user assignment, and a users table with id and name; schema is applied to a working database instance.
- SQL Basics (beginner): API endpoints execute SELECT, INSERT, UPDATE, DELETE queries (via ORM or raw SQL) against the database; queries are observable in logs, test output, or code review and correctly retrieve or modify task and user records.
- CRUD Operations (beginner): All four CRUD operations (create task, read task by id, update task, delete task) are implemented and tested; test output or manual verification shows each operation succeeds with valid input and fails gracefully with invalid input.
- Joins (intermediate): If the implementation includes filtering tasks by user name or listing user assignments, evidence shows a JOIN query (or ORM equivalent) that combines tasks and users tables; if not present in core, assess only if code review reveals the join logic.
- Indexes (intermediate): If performance testing or code review is present, indexes on frequently queried columns (e.g., status, priority, user_id) are defined in the schema; if not explicitly added, assess during comprehension discussion.
- Transactions (intermediate): If the implementation includes multi-step operations (e.g., create task and assign to user atomically), test output or code review shows transaction handling; if not present in core, assess only if code reveals transaction logic.
API Development Fundamentals
- HTTP Basics (beginner): Repository contains working HTTP endpoints (GET, POST, PUT, DELETE) that accept and return data over HTTP; verify by running the service and making requests to at least one endpoint.
- REST Principles (beginner): Endpoints follow REST conventions: resources are nouns (e.g., /tasks, /users), HTTP methods map to actions (POST creates, GET retrieves, PUT updates, DELETE removes), and responses use standard status codes; inspect endpoint definitions and one successful request-response pair.
- CRUD APIs (beginner): All four operations (Create, Read, Update, Delete) are implemented for tasks; verify by executing a test sequence: POST a new task, GET it by ID, PUT to update it, DELETE it, and confirm each returns the expected data and status code.
- Request & Response (beginner): API accepts JSON request bodies with task fields (title, description, status, priority, assignee) and returns JSON responses with task data and metadata; inspect one POST and one GET response in the repository or test output.
- Status Codes (beginner): Endpoints return correct HTTP status codes: 200/201 for success, 400 for invalid input, 401/403 for unauthorized access, 404 for not found, 500 for server error; verify by examining code or test assertions for at least three different status scenarios.
- JSON (beginner): Request payloads and responses are valid JSON; task objects include required fields (title, description, status, priority, assignee); inspect schema in code or sample payloads in tests or documentation.
- API Validation (intermediate): Input validation rejects missing required fields, invalid status/priority values, and malformed JSON; verify by submitting invalid requests (missing title, invalid status enum, non-JSON body) and confirming 400 responses with error messages; inspect validation logic in code.
Security Fundamentals
- Authentication (beginner): Repository contains working login or token-generation endpoint that accepts user credentials and returns a session token or JWT; subsequent requests include this token and are rejected if missing or invalid.
- Authorization (beginner): Repository contains code that checks user identity before returning or modifying tasks; verify at least one endpoint rejects requests from users lacking permission (e.g., user cannot modify another user's task or access admin endpoints without admin role).
- Input Validation (beginner): Repository contains validation logic that rejects requests with missing required fields, invalid data types, or out-of-range values (e.g., invalid status or priority); test suite or manual test confirms malformed JSON is rejected with appropriate error response.
- Password Security (beginner): If user registration or password storage is present in the repository, verify passwords are hashed (not plaintext) using a standard algorithm; if absent, assess only if present.
Software Design Principles
- Separation of Concerns (beginner): Repository contains distinct layers or modules for HTTP request handling, business logic (task validation, filtering, authorization), and data persistence; evidence is observable file/package structure or clear module boundaries in code.
- DRY (beginner): Task filtering logic (by status and priority) and validation rules are implemented once and reused across endpoints; no duplicate filter or validation code in separate route handlers.
- KISS (beginner): Core task CRUD endpoints and user management use straightforward logic without unnecessary abstractions, design patterns, or configuration; code is readable and directly solves the stated requirements.
- SOLID Principles (intermediate): Single Responsibility: each class or function has one reason to change (e.g., TaskRepository handles only database queries, TaskService handles only business rules). Open/Closed: new task statuses or priorities can be added without modifying existing validation logic. Liskov Substitution: if interfaces or base classes are used, derived implementations are substitutable without breaking behavior. Interface Segregation: clients depend on focused interfaces (e.g., TaskReader, TaskWriter) not monolithic ones. Dependency Inversion: high-level business logic does not directly instantiate low-level database or HTTP dependencies; evidence is present only if the implementation uses dependency injection or equivalent inversion pattern.
- Dependency Injection (intermediate): Task service, repository, and HTTP handlers receive their dependencies (database connection, logger, validator) via constructor, factory, or container rather than creating them internally; if not present in core implementation, assess only if learner adds it.
Testing Fundamentals
- Unit Testing (beginner): Repository contains at least one runnable unit test file (e.g., test_*.py, *.test.js, *Test.java, *_test.go, *.Tests.cs) that executes without error and tests a single function or method in isolation.
- Assertions (beginner): Unit tests include at least two distinct assertion statements (e.g., assertEqual, assertTrue, assert, expect) that verify expected vs. actual values or behavior.
- Test Fixtures (beginner): Test file includes setup or teardown logic (e.g., setUp, beforeEach, @Before, fixture decorator) that prepares test data or state before at least one test runs.
- Mocking (intermediate): At least one test file includes a mock or stub object that replaces a real dependency (e.g., database, HTTP client, external service) and verifies the code under test calls it correctly.
- Integration Testing (intermediate): Repository contains at least one test that exercises the full request-response cycle (e.g., HTTP POST to create a task, verify database record exists, check JSON response) without mocking the core API handler or database layer.
Debugging & Troubleshooting
- Breakpoints (beginner): Code repository includes at least one debugger breakpoint or conditional breakpoint in a request handler or business logic function; learner demonstrates stepping through execution or inspecting variables during a live debug session.
- Debugging Techniques (beginner): Repository shows evidence of at least two distinct debugging approaches applied to the core service (e.g., print/log statements, debugger inspection, test-driven isolation, or code review notes); learner explains which technique revealed the bug and why.
- Logging (beginner): Service code includes structured logging at key points (e.g., request entry, validation failure, database operation, error response); logs are written to stdout or a file and can be inspected to trace a request through the system.
- Stack Traces (intermediate): Repository contains at least one test or scenario where an unhandled exception or validation error produces a readable stack trace; learner can read the trace, identify the failing function and line, and explain the call chain that led to the error.
- Root Cause Analysis (intermediate): Learner documents or explains in discussion how they identified and fixed at least one bug in the service (e.g., incorrect status validation, missing null check, database constraint violation); explanation includes what symptom was observed, what the logs or trace revealed, and what change fixed it.
Ai Assisted Software Development
- Working with AI Assistants (beginner): Repository contains at least one commit or code comment showing the learner used an AI assistant (e.g., ChatGPT, GitHub Copilot, Claude) to help write or debug code; evidence includes a reference to the assistant tool and the task it was asked to perform.
- Prompt Writing Fundamentals (beginner): Learner provides a README or inline comment documenting at least one prompt given to the AI assistant; the prompt clearly states the task, context (e.g., language, framework choice, API requirement), and expected output format.
- Code Generation (beginner): Repository contains API endpoint handlers, database models, or request validators generated with AI assistance; learner can trace the prompt used and explain in a commit message or comment how the output was adapted or corrected to match the core scope.
- AI-assisted Debugging (beginner): Learner uses AI to diagnose and fix at least one runtime error or test failure; evidence includes a commit message or code comment linking the problem, the AI prompt, and the resolution applied.
- AI-assisted Refactoring (intermediate): Learner refactors at least one function or module using AI suggestions (e.g., reducing duplication, improving readability); evidence includes before/after code or a commit showing the change and learner rationale for accepting or modifying the suggestion.
- AI-assisted Unit Testing (intermediate): Test suite includes at least two unit tests generated or significantly improved with AI assistance; tests cover task CRUD operations or validation logic and pass; evidence includes a commit or comment linking the AI prompt to the test code.
- AI-assisted Documentation (beginner): README or inline code comments include at least one section (e.g., API endpoint description, setup instructions, or function docstring) generated or refined with AI assistance; learner notes the AI contribution.
- AI Output Validation (intermediate): Learner demonstrates validation of AI-generated code by comparing output against the core specification (e.g., API contract, database schema, test assertions); evidence includes a commit message, test result, or comment showing the learner caught and corrected an error or mismatch.
- AI Limitations & Hallucinations (beginner): Learner documents in a README section or commit comment at least one instance where AI output was incorrect, incomplete, or inconsistent with the specification; learner explains how they identified and fixed the issue.
- Responsible AI Usage (beginner): Learner includes a brief note in the README or code comments acknowledging appropriate use of AI (e.g., for scaffolding and testing, not for bypassing learning), and confirms that the final code is understood and tested by the learner.
Containerization (Docker)
- What is Containerization (beginner): Dockerfile exists in repository root; specifies a base image appropriate to the chosen language, copies application code and configuration, installs runtime dependencies, and exposes the API port (e.g., 8000, 3000, 8080).
- Docker Architecture (beginner): docker build command successfully creates an image from the Dockerfile without errors; image is tagged with a meaningful name and appears in docker images output.
- Docker Images (beginner): Built image contains the application code, dependencies, and runtime; image can be inspected with docker inspect or docker history to verify layers and metadata.
- Docker Containers (beginner): docker run command starts a container from the built image; the service listens on the mapped port and responds to HTTP requests (e.g., GET /tasks returns 200 with JSON).
- Dockerfile Basics (beginner): Dockerfile uses a minimal base image, copies only necessary files, installs dependencies via language-native package manager (pip, npm, Maven, dotnet, go mod), sets a working directory, and declares EXPOSE for the API port.
- Building Images (beginner): docker build -t taskservice:latest . executes without errors; resulting image is listed in docker images and has a reasonable size for the language and dependencies chosen.
- Running Containers (beginner): docker run -p 8000:8000 taskservice:latest (or equivalent port mapping) starts the container; service is accessible at localhost:PORT and responds to at least one API endpoint with correct JSON.
- Environment Variables (beginner): Dockerfile or docker-compose.yml defines DATABASE_URL, API_PORT, or equivalent environment variables; running container reads these values from -e flags or .env file and applies them (verify via logs, config output, or request behavior).
- Docker Volumes (beginner): If present in the repository, docker-compose.yml or docker run command includes a volume mount for database persistence or application logs; data persists across container restarts or is explicitly documented as in-memory for prototype scope.
- Docker Networks (beginner): If docker-compose.yml is present, services (app and database) are defined on the same network and communicate by service name; if using docker run, network is created or default bridge is used and port mapping allows inter-container or host access.
- Docker Compose (intermediate): docker-compose.yml defines at least the application service with image, ports, environment variables, and volumes; docker-compose up starts all services without errors; docker-compose down stops and removes containers cleanly.
- Container Debugging (intermediate): Learner can execute docker logs CONTAINER_ID to view application output; docker exec -it CONTAINER_ID sh (or language-native shell) allows inspection of running container filesystem and processes; at least one debugging step is documented or demonstrated in README or commit message.
What to explain
AI assistance is allowed while building the submission. During the comprehension conversation, answer independently without AI tools, search, or outside help. Be ready to trace your actual code, explain decisions and limitations, and reason about a small change or failure case. Conceptual topics do not require a separate coded feature.
Version Control
- Repository Setup (beginner): Explain why a .gitignore file is necessary and what types of files should be excluded from version control in a backend service project.
- Basic Commands (beginner): Describe the difference between git add and git commit, and why both steps are needed to save changes to the repository.
- Commits (beginner): Explain what makes a good commit message and why breaking work into multiple commits is better than one large commit.
- Branching (beginner): Describe why feature branches are used instead of committing directly to main, and how they support team collaboration.
- Merging (beginner): Explain the purpose of merging and what happens to the commit history when a feature branch is merged into main.
- Conflict Resolution (intermediate): Walk through a merge conflict scenario: when it occurs, how to identify conflicting sections, and the steps to resolve it manually.
- Pull Requests (intermediate): Explain the purpose of a pull request in a team workflow, what information should be included in the description, and how code review before merge improves quality.
Programming Fundamentals
- Variables & Data Types (beginner): Explain why you chose specific data types (string vs. integer, enum vs. string) for task fields and how type mismatches could cause bugs in filtering or API responses.
- Operators (beginner): Describe how you use comparison and logical operators to validate a task status change request and reject invalid transitions.
- Expressions (beginner): Walk through an example expression that filters tasks by priority and status; explain the order of evaluation and how the result is used in the response.
- Control Flow (beginner): Trace the control flow for a POST request to create a task: which conditions are checked, in what order, and what happens if validation fails.
- Functions & Methods (beginner): Explain the purpose of each function you wrote for CRUD operations and why breaking them into separate functions improves code clarity and testability.
- Collections (intermediate): Show how you iterate over the task collection to filter by status; explain why you chose that approach (e.g., loop, map, filter method) and how it handles an empty result set.
- Exception Handling (intermediate): Describe a specific error scenario (e.g., database connection failure, malformed JSON input) and show how your code catches and handles it; explain why returning an error response is better than letting the exception propagate.
- File Handling (beginner): If file I/O is present, explain how you read task data on startup and write updates; if not used, confirm that data persistence is handled by another mechanism (e.g., database library) and explain why.
Object-oriented Programming
- Classes & Objects (beginner): Explain why Task and User are separate classes and what responsibility each holds in the domain model.
- Constructors (beginner): Describe what parameters the Task and User constructors accept and why each is necessary for initialization.
- Encapsulation (beginner): Explain how encapsulation protects the internal state of a Task or User object and give an example of a property that should not be directly modified from outside.
- Inheritance (intermediate): If a base class or abstract entity is used, explain what behavior or properties are shared and why inheritance reduces code duplication; if not implemented, explain when inheritance would be appropriate in this service.
- Polymorphism (intermediate): If method overriding or interface implementation is present, explain how it allows different entity types or handlers to respond differently to the same operation; if not implemented, describe a scenario where polymorphism would improve the design.
- Abstraction (intermediate): Explain what an interface or abstract class in the codebase abstracts away and why that abstraction makes the code more flexible or testable; if not implemented, describe what behavior could be abstracted.
- Interfaces (intermediate): If interfaces are used, explain the contract they define and how concrete implementations satisfy it; if not implemented, describe what interface would improve the design.
- Composition (intermediate): Explain how Task or User uses composition to include other objects, why composition is chosen over inheritance in that case, and how the composed object is used in the class methods.
Data Structures & Algorithms
- Arrays (beginner): Explain how arrays store task data in order and why indexed access is useful for task retrieval.
- Lists (beginner): Describe the difference between arrays and linked lists, and when each is appropriate for storing tasks.
- Stacks (beginner): Explain the LIFO principle and give a scenario where a stack could be used in a task management system (e.g., undo history).
- Queues (beginner): Explain the FIFO principle and describe how a queue could model task processing or request handling.
- Hash Tables (intermediate): Explain why hash tables provide O(1) lookup for tasks by ID and how collisions are handled; critique the choice of hash table vs. linear search for task retrieval.
- Sorting (intermediate): Explain the sorting algorithm used (e.g., quicksort, mergesort, built-in sort) and its time complexity; justify why sorting by priority before returning results improves user experience.
- Searching (intermediate): Explain the filtering algorithm and why filtering before returning results is more efficient than returning all tasks and filtering on the client; compare linear search vs. indexed search.
- Time Complexity (intermediate): Analyze the time complexity of task lookup by ID, filtering by status, and sorting by priority; identify bottlenecks and suggest optimizations (e.g., indexing, caching).
Database Fundamentals
- Relational Databases (beginner): Explain why a relational database is suitable for this task collaboration tool compared to a flat file or spreadsheet; describe the relationship between tasks and users.
- SQL Basics (beginner): Walk through one SELECT query from your code; explain what columns are retrieved, what conditions filter the results, and how the query maps to an API endpoint.
- CRUD Operations (beginner): Describe the four CRUD operations you implemented; for one operation, explain how your code validates input before writing to the database.
- Joins (intermediate): Explain the difference between an INNER JOIN and a LEFT JOIN; describe a scenario in your task API where each would be useful.
- Indexes (intermediate): Explain why an index on the status column would improve query performance for filtering tasks by status; what is the tradeoff of adding an index?
- Transactions (intermediate): Describe a scenario in your task API where two database operations must succeed or fail together; explain how transactions ensure consistency.
API Development Fundamentals
- HTTP Basics (beginner): Explain the role of HTTP methods (GET, POST, PUT, DELETE) in your API and why each is used for its corresponding operation.
- REST Principles (beginner): Describe how your API follows REST conventions: how resources are identified by URLs, how HTTP methods represent actions, and why this design makes the API predictable for clients.
- CRUD APIs (beginner): Walk through a complete task lifecycle: creating a task, retrieving it, modifying it, and deleting it; explain what happens at each step and how the API state changes.
- Request & Response (beginner): Show a sample JSON request body for creating a task and the corresponding response; explain what information is sent and what is returned.
- Status Codes (beginner): Explain why your API returns 201 for a successful POST (create) versus 200 for a successful GET, and give an example of when you would return 400 versus 404.
- JSON (beginner): Describe the structure of a task object in your API (fields, data types, required vs optional); explain why JSON is a good choice for API communication.
- API Validation (intermediate): Describe the validation rules you implemented (e.g., title must not be empty, status must be one of todo/in-progress/done); explain how validation prevents bad data from entering the database and improves API reliability.
Security Fundamentals
- Authentication (beginner): Explain how the login flow works: what credentials are accepted, how the token is generated, and how it is validated on subsequent requests.
- Authorization (beginner): Describe the access control model: what roles or user types exist, which operations require which permissions, and how the code enforces these rules.
- Input Validation (beginner): Walk through one example of invalid input (e.g., missing title, invalid priority value) and explain how the service detects and rejects it.
- Password Security (beginner): If passwords are stored, explain why hashing is necessary and name the algorithm used; if not present, explain the security risk of storing plaintext passwords and how a hash function mitigates it.
Software Design Principles
- Separation of Concerns (beginner): Explain how you separated HTTP handling from business logic and data access. Why is this separation valuable for testing and maintenance?
- DRY (beginner): Identify one piece of duplicated or repeated logic in your code (or a hypothetical scenario). How would you refactor it to follow DRY?
- KISS (beginner): Describe one design decision you made to keep the code simple. What complexity did you avoid, and why?
- SOLID Principles (intermediate): Choose one SOLID principle you applied (or attempted to apply) in your implementation. Show a code example and explain how it improves the design. If you did not apply SOLID, describe how you would refactor one class or module to follow a specific principle.
- Dependency Injection (intermediate): Explain how your service receives its dependencies (database, logger, validator). Why is injecting dependencies better than having the service create them? If you did not use dependency injection, describe how you would refactor one component to use it.
Testing Fundamentals
- Unit Testing (beginner): Explain why unit tests are written for individual functions rather than the entire API, and name one benefit of isolating code under test.
- Assertions (beginner): Describe what an assertion does and why it is necessary in a test; give an example of an assertion that would fail if the task creation endpoint returned status 500 instead of 201.
- Test Fixtures (beginner): Explain the purpose of test setup (e.g., creating a temporary database or in-memory data structure) and how it helps keep tests independent.
- Mocking (intermediate): Describe a scenario in which mocking a database or external API is preferable to using the real dependency in a test, and explain what behavior you would verify on the mock.
- Integration Testing (intermediate): Explain how an integration test differs from a unit test; describe what an integration test for the task creation endpoint would verify end-to-end (e.g., request parsing, validation, database insert, response serialization).
Debugging & Troubleshooting
- Breakpoints (beginner): Explain when and why you set a breakpoint in your code. What variable or condition did you inspect, and how did that help you understand the bug?
- Debugging Techniques (beginner): Describe two different debugging techniques you used to find a problem in the service. Which one was faster or more effective, and why?
- Logging (beginner): Show an example log line from your service. What information does it capture, and how would a developer use it to diagnose a problem?
- Stack Traces (intermediate): Walk through a stack trace from your service. Identify the top-level error, the function where it occurred, and the chain of calls that led to it. What does the trace tell you about what went wrong?
- Root Cause Analysis (intermediate): Describe a bug you found and fixed in the service. What was the symptom (e.g., API returned wrong status code, test failed)? What did the logs or debugger show? What was the root cause, and how did you verify the fix?
Ai Assisted Software Development
- Working with AI Assistants (beginner): Explain which AI assistant tool you chose and why; describe one task you delegated to it and one task you handled yourself, and justify the split.
- Prompt Writing Fundamentals (beginner): Review one prompt you wrote to the AI; identify what context or constraints you included, and explain how the prompt could have been clearer or more specific.
- Code Generation (beginner): Show one piece of AI-generated code in your repository; explain what the AI was asked to do, what it produced, and what you changed before merging it into the core.
- AI-assisted Debugging (beginner): Describe a bug or test failure you encountered; explain how you used the AI to diagnose it, what the AI suggested, and whether you applied the suggestion as-is or modified it.
- AI-assisted Refactoring (intermediate): Identify one function or module the AI helped you refactor; compare the before and after code, and explain whether the refactoring improved readability, reduced duplication, or introduced any trade-offs.
- AI-assisted Unit Testing (intermediate): Show two unit tests the AI helped you write; explain what each test covers, whether the AI-generated test code was correct on the first try, and what corrections you made.
- AI-assisted Documentation (beginner): Point to one section of your README or docstring that the AI helped write; assess whether it accurately describes the code or API, and note any corrections you made.
- AI Output Validation (intermediate): Describe a case where AI-generated code did not match the specification; explain how you detected the mismatch (e.g., test failure, manual review, or API contract check) and how you corrected it.
- AI Limitations & Hallucinations (beginner): Give an example of AI output that was incorrect or incomplete; explain what the AI got wrong, how you discovered the error, and how you fixed it.
- Responsible AI Usage (beginner): Reflect on your use of AI in this project; explain what parts of the code you understand fully, what you verified through testing, and what you would do differently to ensure the code is maintainable and trustworthy.
Containerization (Docker)
- What is Containerization (beginner): Explain why containerization isolates the application from the host system and how it ensures the service runs the same way on any developer machine or production server.
- Docker Architecture (beginner): Describe the relationship between the Docker daemon, images, and containers; explain how an image is a blueprint and a container is a running instance.
- Docker Images (beginner): Explain what layers are in a Docker image, why base images matter, and how the Dockerfile instructions build up the final image.
- Docker Containers (beginner): Describe the lifecycle of a container (create, start, run, stop, remove) and how port mapping connects the container port to the host.
- Dockerfile Basics (beginner): Explain the purpose of FROM, COPY, RUN, EXPOSE, and CMD instructions; justify the choice of base image for the selected language.
- Building Images (beginner): Explain what docker build does, why tagging is important, and how to interpret build output and layer caching.
- Running Containers (beginner): Explain the docker run command syntax, what -p does, how to verify the container is running (docker ps), and how to stop it.
- Environment Variables (beginner): Explain why environment variables are used in containers, how they are passed at runtime, and why hardcoding values in the image is problematic.
- Docker Volumes (beginner): Explain the difference between volumes and bind mounts, why persistence is needed for a database, and how to verify data survives a container restart.
- Docker Networks (beginner): Explain how containers communicate, why service names work in docker-compose networks, and how port mapping differs from internal networking.
- Docker Compose (intermediate): Explain why docker-compose.yml simplifies multi-container setups, how services are defined and linked, and how to override environment variables or scale services.
- Container Debugging (intermediate): Explain how to use docker logs, docker exec, and docker inspect to troubleshoot a failing container; describe a scenario where you would use each tool and what information it provides.
How to submit
- Before you start, register on the SahkaarX platform and connect your GitHub account.
- When the challenge begins, SahkaarX will create a private GitHub repository under your account and notify you in the app and via push notification.
- Clone the repository, implement the API and tests, commit your work with clear messages, and push to the main branch.
- Submit your solution in the app by selecting the system-created repository; do not create your own GitHub repo.
What happens after you submit
When the challenge window closes, an automated repository review will analyze your code, database schema, tests, and Docker configuration. You will then complete a mandatory in-app conversation where you explain your design decisions, walk through key code sections, and discuss how you validated your solution. This conversation verifies that you understand your own work and can reason about trade-offs. If human judges are assigned, they will review your repository score and conversation transcript before final results are published; otherwise results finalize automatically after the conversation.
Intellectual property
You retain full ownership of the code and design in your submission. SahkaarX may host, evaluate, display on leaderboards, and operate the challenge using your work. Your GitHub repository remains private under your account; you control access and can modify or delete it after the challenge ends. By submitting, you grant SahkaarX a non-exclusive license to evaluate and showcase your solution as part of the challenge platform.
Skills You’ll Put to Work
Version Control
- Repository SetupBeginnerFundamental
- Basic CommandsBeginnerFundamental
- CommitsBeginnerFundamental
- BranchingBeginnerFundamental
- MergingBeginnerFundamental
- Conflict ResolutionIntermediateFundamental
- Pull RequestsIntermediateFundamental
Programming Fundamentals
- Variables & Data TypesBeginnerFundamental
- OperatorsBeginnerFundamental
- ExpressionsBeginnerFundamental
- Control FlowBeginnerFundamental
- Functions & MethodsBeginnerFundamental
- CollectionsIntermediateFundamental
- Exception HandlingIntermediateFundamental
- File HandlingBeginnerFundamental
Object-oriented Programming
- Classes & ObjectsBeginnerFundamental
- ConstructorsBeginnerFundamental
- EncapsulationBeginnerFundamental
- InheritanceIntermediateFundamental
- PolymorphismIntermediateFundamental
- AbstractionIntermediateFundamental
- InterfacesIntermediateFundamental
- CompositionIntermediateFundamental
Data Structures & Algorithms
- ArraysBeginnerFundamental
- ListsBeginnerFundamental
- StacksBeginnerFundamental
- QueuesBeginnerFundamental
- Hash TablesIntermediateFundamental
- SortingIntermediateFundamental
- SearchingIntermediateFundamental
- Time ComplexityIntermediateFundamental
Database Fundamentals
- Relational DatabasesBeginnerFundamental
- SQL BasicsBeginnerFundamental
- CRUD OperationsBeginnerFundamental
- JoinsIntermediateFundamental
- IndexesIntermediateFundamental
- TransactionsIntermediateFundamental
API Development Fundamentals
- HTTP BasicsBeginnerFundamental
- REST PrinciplesBeginnerFundamental
- CRUD APIsBeginnerFundamental
- Request & ResponseBeginnerFundamental
- Status CodesBeginnerFundamental
- JSONBeginnerFundamental
- API ValidationIntermediateFundamental
Security Fundamentals
- AuthenticationBeginnerFundamental
- AuthorizationBeginnerFundamental
- Input ValidationBeginnerFundamental
- Password SecurityBeginnerFundamental
Software Design Principles
- Separation of ConcernsBeginnerFundamental
- DRYBeginnerFundamental
- KISSBeginnerFundamental
- SOLID PrinciplesIntermediateFundamental
- Dependency InjectionIntermediateFundamental
Testing Fundamentals
- Unit TestingBeginnerFundamental
- AssertionsBeginnerFundamental
- Test FixturesBeginnerFundamental
- MockingIntermediateFundamental
- Integration TestingIntermediateFundamental
Debugging & Troubleshooting
- BreakpointsBeginnerFundamental
- Debugging TechniquesBeginnerFundamental
- LoggingBeginnerFundamental
- Stack TracesIntermediateFundamental
- Root Cause AnalysisIntermediateFundamental
Ai Assisted Software Development
- Working with AI AssistantsBeginnerFundamental
- Prompt Writing FundamentalsBeginnerFundamental
- Code GenerationBeginnerFundamental
- AI-assisted DebuggingBeginnerFundamental
- AI-assisted RefactoringIntermediateFundamental
- AI-assisted Unit TestingIntermediateFundamental
- AI-assisted DocumentationBeginnerFundamental
- AI Output ValidationIntermediateFundamental
- AI Limitations & HallucinationsBeginnerFundamental
- Responsible AI UsageBeginnerFundamental
Containerization (Docker)
- What is ContainerizationBeginnerFundamental
- Docker ArchitectureBeginnerFundamental
- Docker ImagesBeginnerFundamental
- Docker ContainersBeginnerFundamental
- Dockerfile BasicsBeginnerFundamental
- Building ImagesBeginnerFundamental
- Running ContainersBeginnerFundamental
- Environment VariablesBeginnerFundamental
- Docker VolumesBeginnerFundamental
- Docker NetworksBeginnerFundamental
- Docker ComposeIntermediateFundamental
- Container DebuggingIntermediateFundamental
Before You Register
- Prerequisites: review the target audience, skills covered, and challenge brief.
- Deadlines: check the key dates and complete required submissions before the challenge deadline.
- Participation: Solo only.
- Evaluation: review the brief and FAQs for scoring criteria and how your work will be assessed.
- AI assistance: check this challenge's rules before using AI tools. If the rules are unclear, ask support before submitting.
Questions? Contact SahkaarX support.
Intellectual property: participants retain
Frequently Asked Questions
Who can join this challenge?
This is an open challenge for entry-level software engineers. Solo participation is required; teams are not allowed. You must have a GitHub account and be able to commit code.
How does GitHub repository setup work?
Do not create your own repository. When you register and the challenge starts, SahkaarX automatically creates a private repo under your GitHub account and sends you a notification. Clone that repo, implement your solution, and push your commits there.
When does evaluation happen?
Evaluation begins when the challenge window closes, not immediately after you submit. An automated review analyzes your code, tests, and Docker setup. You will then participate in a mandatory in-app conversation to discuss your implementation.
What is the mandatory in-app conversation?
After your repository is reviewed, you will have a structured conversation in the app where you explain your design, walk through key code sections, and discuss your testing strategy. This verifies you understand your own work; it is not a written quiz. Stay on the comprehension page to complete it.
Skill feedback helps you decide what to practise next. Learning plans follow eligible evaluated results; additional plans are paid. No job guarantee.