Training Trains logo

Backend Development Internship

Build the server side of real applications: REST APIs, databases, authentication, caching, background jobs and deployment.

Node.js or PythonPostgreSQL / MySQLRedisDockerPostman

What you'll work on

Full syllabus: all 60 graded tasks

These are the actual tasks the internship portal assigns for this domain. You submit each one with proof (a GitHub link or document) and a mentor reviews it.

Level 1: Foundations (24 tasks)
  1. How HTTP works. Use curl -v against two APIs and explain methods, status codes, headers and the body for each request in a README.
  2. Your first server. Create a Node.js (Express) or Python (Flask/FastAPI) server with three routes returning JSON. Commit it to a repo named backend-internship.
  3. REST design for a resource. Design REST endpoints for a library (books, members, loans) with methods, URLs, status codes and sample JSON.
  4. CRUD with an in-memory store. Implement create, read, update and delete for books, with proper 201/404/400 responses.
  5. Input validation. Validate request bodies with a library (zod, Joi or Pydantic) and return clear error messages for bad input.
  6. Connect a SQL database. Move the books store to PostgreSQL, MySQL or SQLite. Write the CREATE TABLE statements and commit them.
  7. SQL queries practice. Write 10 SQL queries on your library data: filters, joins, GROUP BY, ORDER BY and a subquery, with results.
  8. Environment variables. Move database URLs and secrets into environment variables with a .env.example file and explain why secrets never go in Git.
  9. Logging requests. Add request logging with method, path, status and duration. Show a sample of the log.
  10. Error handling middleware. Add one central error handler so every error returns the same JSON shape without leaking stack traces.
  11. API documentation. Document your API with OpenAPI/Swagger and serve the docs page from the server.
  12. Test the API with Postman. Create a Postman collection with tests for every endpoint and export it to the repo.
  13. Status code cheat sheet. Write a cheat sheet of 20 status codes with one example request for each from your own API.
  14. Config per environment. Load different settings for development, test and production without code changes.
  15. Request IDs. Add a unique request ID to every request and include it in logs and error responses.
  16. Seed data script. Write a script that fills the database with realistic sample data for development.
  17. Soft delete. Implement soft delete for books (deletedAt column) and exclude deleted rows from lists.
  18. Timestamps and time zones. Store created and updated times in UTC and return ISO 8601 strings. Explain why.
  19. CSV export. Add an endpoint that streams a CSV export of records without loading everything into memory.
  20. Search endpoint. Add case-insensitive search across two fields with SQL LIKE or full-text search.
  21. Health and readiness. Add separate liveness and readiness endpoints and explain the difference.
  22. API versioning. Serve /v1 and /v2 of one endpoint where v2 changes the response shape.
  23. Basic auth vs API key. Protect an admin endpoint with an API key header and explain its limits.
  24. Linting and formatting. Add a linter and formatter to the project and fix every warning.
Level 2: Building real features (20 tasks)
  1. Authentication with passwords. Add sign-up and login with bcrypt-hashed passwords. Explain why you never store plain passwords.
  2. JWT or session auth. Protect the write endpoints with JWT or sessions. Show what happens with no token, an expired token and a valid one.
  3. Roles and permissions. Add admin and member roles. Only admins can delete books. Write tests for both roles.
  4. Pagination, filtering and sorting. Add page, limit, search and sort query parameters to the books list with safe defaults and limits.
  5. Database migrations. Use a migration tool (Prisma, Knex, Alembic or Flyway) to create and change the schema in versioned steps.
  6. Indexes and query plans. Load 50,000 rows, time a slow query, add an index and show EXPLAIN output before and after.
  7. Automated API tests. Write integration tests that start the server with a test database and cover the main flows.
  8. File uploads. Add a book cover upload with size and type checks, storing files on disk or in cloud storage.
  9. Rate limiting. Limit login attempts per IP and return 429 with a Retry-After header. Explain why this matters.
  10. Containerise the API. Write a Dockerfile and docker-compose file that runs the API and database together with one command.
  11. Refresh tokens. Add short-lived access tokens and long-lived refresh tokens with rotation and logout.
  12. Password reset flow. Build a secure password reset with one-time, expiring tokens.
  13. Email verification. Send a verification link on sign-up and block unverified users from some actions.
  14. Audit log. Record who changed what and when for every write, and add an endpoint to read the log.
  15. N+1 query fix. Find an N+1 query in your API, fix it with a join or batching, and measure the difference.
  16. Idempotent payments. Implement an Idempotency-Key header so retried create requests do not create duplicates.
  17. Scheduled jobs. Run a nightly job that cleans expired sessions or sends a report.
  18. Object storage. Store uploaded files in S3-compatible storage with signed URLs for download.
  19. GraphQL endpoint. Expose the same data through a small GraphQL API and compare it with REST.
  20. Load test. Load-test your API with k6 or autocannon and find the first bottleneck.
Level 3: Professional work and capstone (16 tasks)
  1. Caching with Redis. Cache the books list in Redis with a sensible expiry and clear it when a book changes. Measure the speed-up.
  2. Background jobs. Send a welcome email (or log it) through a background job queue instead of inside the request.
  3. Transactions and consistency. Make borrowing a book a database transaction so stock can never go negative, and prove it with a concurrent test.
  4. Webhooks. Build an endpoint that receives a webhook, verifies its signature and processes it exactly once.
  5. OWASP API security check. Review your API against the OWASP API Top 10 and fix at least three findings, documenting each.
  6. Observability. Add a /health endpoint, structured JSON logs and basic metrics (request count and latency).
  7. Deploy with CI. Deploy the API to a free host (Render, Railway or Cloud Run) with a GitHub Actions pipeline that runs tests first.
  8. Capstone: production backend. Ship a complete backend for an app of your choice with auth, database, tests, docs, Docker and a live URL. Include an architecture diagram in the README.
  9. Message queue integration. Publish an event when an order is placed and process it in a separate worker.
  10. Multi-tenant design. Add tenant separation so each organisation sees only its own data, with tests.
  11. Search engine. Index records in Elasticsearch, Meilisearch or Typesense and add fast search with filters.
  12. Distributed tracing. Add OpenTelemetry tracing across your API and worker and view a trace.
  13. Database backup and restore. Automate daily database backups and practise a restore to a new database.
  14. Zero-downtime migration. Change a column in a way that never breaks running code (expand and contract).
  15. Backend code review. Review a classmate's backend pull request for security, errors and performance.
  16. Capstone 2: SaaS backend. Build a multi-tenant SaaS backend with billing-ready plans, roles, audit logs, background jobs, tests and deployment.

Real software work, not just training

Every Backend Development task is reviewed by our team and saved to your portfolio. Interns who pass the readiness check can take real work from Training Trains, W3AppDevelopers and DomainHostly projects on the Company Work board.

Full Stack Web Application DevelopmentHosting and Domain Solutions
See the software we build →

Frequently asked questions

Do I need experience to join the Backend Development internship?+

Basic programming in any language helps. HTTP and databases are taught from the start.

What will I do in the Backend Development internship?+

You complete 60 graded tasks in three levels: foundations, real features, and professional work. Each task is submitted with GitHub or document proof and reviewed. The final capstone is: Capstone 2: SaaS backend.

Do I get a certificate for the Backend Development internship?+

Yes. After your required tasks are approved, your attendance is above 75% and you pass the proctored final exam, you get a graded completion certificate that anyone can verify at trainingtrains.com/verify.

Can I do the Backend Development internship online?+

Yes. You can do it fully online from home, or offline at our Erode and Perundurai branches. Tasks, quizzes and mentor reviews are the same in both modes.

Available both online (work from home) and offline at our Erode and Perundurai branches - see the full internship program details for departments, duration, and the application process.

Apply for the Backend Development internship