Training Trains logo

Software Architecture Internship

Learn how large systems are designed: quality attributes, design patterns, monoliths vs microservices, scaling, resilience and clear architecture documents.

C4 diagramsADRsDockerMessage queuesOpenTelemetry

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. What architects do. Write a page on the role of a software architect: decisions, trade-offs, communication and quality attributes.
  2. Quality attributes. Define performance, scalability, availability, security, maintainability and cost, with a measurable example for each.
  3. Layered architecture. Build a small app with presentation, business and data layers, and explain what each layer may and may not call.
  4. SOLID principles. Show each SOLID principle with a short bad and good code example.
  5. Design patterns tour. Implement Factory, Strategy, Observer and Adapter in one language, with a real use case for each.
  6. UML and C4 diagrams. Draw a C4 context and container diagram for an online food-ordering app.
  7. Monolith analysis. Pick an open-source monolith on GitHub and describe its modules and how they depend on each other.
  8. API contracts. Write an OpenAPI contract for a service before writing its code, and explain contract-first design.
  9. Coupling and cohesion. Find a tightly coupled piece of code (yours or open source) and refactor it to reduce coupling.
  10. Architecture decision record. Write an ADR choosing between SQL and NoSQL for a project, with context, options and consequences.
  11. Non-functional requirements. Write NFRs for a college result portal: load, response time, uptime, security and data retention.
  12. Read a real case study. Summarise an engineering blog post about a large system's architecture and list three lessons.
  13. Architecture katas. Solve one architecture kata (a short design exercise) in 45 minutes and write up your design.
  14. Component diagram. Draw a C4 component diagram for one container of an app you built.
  15. Dependency graph. Generate a dependency graph of a project's modules and find any cycles.
  16. Twelve-factor app. Check an app against the twelve-factor principles and fix two gaps.
  17. Clean architecture. Explain clean/hexagonal architecture and restructure a small app into ports and adapters.
  18. Interface design. Design interfaces for a payment module so the provider can be swapped easily.
  19. Error handling strategy. Write an error handling and logging strategy for a whole application.
  20. Configuration strategy. Design how configuration and feature flags are managed across environments.
  21. Code review for design. Review a pull request only for design issues (coupling, naming, boundaries).
  22. Read an ADR log. Read the ADRs of an open-source project and summarise three decisions.
  23. Sequence diagram. Draw a sequence diagram for a login and an order checkout flow.
  24. Glossary for a domain. Create a ubiquitous language glossary for an online learning platform.
Level 2: Building real features (20 tasks)
  1. Client-server and n-tier. Deploy a three-tier app (frontend, API, database) and document how requests flow.
  2. Modular monolith. Restructure an app into clear modules with public interfaces and no cross-module database access.
  3. Microservices split. Split one app into two services that talk over HTTP, and list the new problems this created.
  4. Event-driven design. Make two services communicate through a message queue (RabbitMQ, Kafka or a cloud queue) and explain why.
  5. Caching strategy. Add a cache to a slow endpoint and explain cache-aside, TTLs and invalidation in your design.
  6. Database scaling. Explain replicas, sharding and partitioning, and design how your app's data would scale to 10 million users.
  7. API gateway. Put an API gateway or reverse proxy (NGINX) in front of your services for routing, rate limiting and TLS.
  8. Resilience patterns. Implement retries with backoff, timeouts and a circuit breaker between two services.
  9. Domain-driven design. Identify bounded contexts, entities and aggregates for an e-commerce system and draw a context map.
  10. Trade-off analysis. Compare REST, GraphQL and gRPC for one use case and recommend one with reasons.
  11. Event storming. Run an event storming session (even alone) for a food delivery system and capture events, commands and aggregates.
  12. Data ownership. Decide which service owns each data entity in a microservice design and how others get it.
  13. Outbox pattern. Implement the transactional outbox pattern so events are published reliably.
  14. Idempotent consumers. Make a message consumer safe to process the same message twice.
  15. API composition. Build a backend-for-frontend that combines data from two services for one screen.
  16. Feature toggles. Add feature flags to release a feature gradually and remove the flag afterwards.
  17. Multi-region thinking. Explain how you would serve users in India and Europe with low latency and data rules.
  18. Capacity estimate. Estimate storage, bandwidth and QPS for a photo-sharing app with 1 million users.
  19. Read model. Build a separate read-optimised model (CQRS) for a reporting screen.
  20. Architecture fitness tests. Write automated tests that fail if a forbidden module dependency is added.
Level 3: Professional work and capstone (16 tasks)
  1. Design a URL shortener. Produce a full design: requirements, API, data model, scaling, caching and a capacity estimate.
  2. Design a chat system. Design a real-time chat with presence and message history, and explain your choice of WebSockets and storage.
  3. Observability architecture. Design logging, metrics and tracing for a microservice system and set up a small demo with OpenTelemetry.
  4. Security architecture. Design authentication, authorisation, secrets and encryption for a multi-service app.
  5. Cost-aware cloud design. Design a cloud deployment for a startup and estimate its monthly cost with the provider's calculator.
  6. Architecture review. Review a classmate's or open-source project's architecture and write a constructive report with risks and fixes.
  7. Migration plan. Write a step-by-step plan to move a monolith to services using the strangler pattern, with risks at each step.
  8. Capstone: architecture document. Produce a complete architecture document for a real product idea: context, C4 diagrams, ADRs, NFRs, scaling, security and a prototype of the hardest part.
  9. Design a payment system. Design a payment system with idempotency, ledgers, reconciliation and failure handling.
  10. Design a notification system. Design email, SMS and push notifications with preferences, retries and rate limits.
  11. Design a search system. Design search with indexing, ranking and freshness for an e-commerce catalogue.
  12. Design a video platform. Design upload, transcoding, storage and streaming with a CDN.
  13. Platform engineering. Design an internal developer platform with templates, CI/CD and self-service environments.
  14. Sustainability. Estimate the carbon and cost impact of a design and suggest greener choices.
  15. Architecture presentation. Present an architecture to non-technical stakeholders in 10 minutes and collect feedback.
  16. Capstone 2: design portfolio. Publish three complete system designs with diagrams, trade-offs, estimates and ADRs as a portfolio site.

Real software work, not just training

Every Software Architecture 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 Development
See the software we build →

Frequently asked questions

Do I need experience to join the Software Architecture internship?+

You should already build small apps in one language. This domain suits final-year students and graduates.

What will I do in the Software Architecture 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: design portfolio.

Do I get a certificate for the Software Architecture 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 Software Architecture 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 Software Architecture internship