Skip to main content

IT Base

In this module, we need to close all the gaps in the basics of Software Engineering and the main topics of backend development.​

про Lite backend development блок

IMFO: An Applied AI engineer does not have to be a backend development specialist, but you should delve into it yourself with the level of immersion + skip familiar topics.

  • Want to get to Agent development faster? - study these topics superficially - returning to immersion in SWE during industrial development.
    • For Full-time learners: spend 0.5-1 days per module
    • For Part-time learners: spend 1-2 days per module
  • Want in-depth knowledge? - will be useful for future architects
    • For Full-time learners: spend 1-2 days per module, superficially go through the Extra/Silver sections
    • For Part-time learners: spend 2-4 days per module, superficially go through the Extra/Silver sections
instruction

Since these topics do not change over time, it is best for you to study them with a personal teacher - ChatGPT.

The learning process should be as follows:

  • you create a system prompt for ChatGPT (templates), where you describe your background, preferences, level of detail of explanations, etc.
  • copy the topic from the list (triple click), and ask ChatGPT to explain this topic to you
  • if you want to delve deeper, ask clarifying questions

At the moment, this is the most convenient way to study the basics. In addition to concepts, you can study additional materials in the Gold, Silver, Extra sections.

  1. Gold - it is imperative to study before communicating with ChatGPT
  2. Ask AI - ask questions on each unfamiliar topic
  3. Silver - secondary materials
  4. Extra - in-depth topics

Gold​

1. Not grouped​

System Design Fundamentals by ByteByteGo
Videos by ByteByteGo

2. Git and Github​

Git and Github

Ask AI​

Ask ChatGPT

Topics for sequential study with ChatGPT (grouped by category):

Network basics and protocols​

How the internet works

  1. HTTP vs HTTPS: key differences and impact on security

  2. TCP/IP: basic principles of operation (briefly)

  3. HTTP status codes: practical application (2xx, 4xx, 5xx)

    HTTP status codes: classification and use (2xx, 4xx, 5xx), briefly

  4. WebSockets vs HTTP Long Polling: comparison of approaches (concept)

  5. CORS: configuring security for cross-domain requests

    CORS in 100 Seconds

API and web service architecture​

  1. REST vs SOAP: comparison for beginners

  2. Stateless vs Stateful: advantages for scaling

  3. CRUD operations: basic data handling patterns

  4. RESTful API: 6 key design principles

  5. API versioning: strategies for backward compatibility

  6. OpenAPI/Swagger: documentation automation (overview)

  7. GraphQL vs REST: technology selection criteria

    GraphQL vs REST: when to use

  8. Webhooks: implementation of asynchronous notifications

    Webhooks: operating mechanisms and applications

  9. API Gateway: architectural patterns (overview)

    API Gateway: role in microservice architecture

  10. API rate limiting: protection against DDoS and abuse

  11. Microservices vs Monolith: trade-off analysis

    Microservices vs Monolith: when to use what

Development and testing principles​

  1. SOLID: practical application in the backend

  2. DRY/KISS/YAGNI: antipatterns and solutions

  3. Testing in the backend: test pyramid (comparison)

    Top 9 Most Popular Types of API Testing
    API Testing Types

  4. TDD: workflow for beginners

  5. A/B testing: architectural approaches

  6. Feature flags: release management (briefly)

  7. SemVer: semantic versioning in practice

  8. Structured logs: best practices

  9. Monitoring: key SLA metrics

  • Error handling and logging: standard approaches, middleware
  • Proxy servers

Git and CI/CD​

  1. Git-flow: branching strategies in a team
  2. CI/CD: pipeline from commit to production

Security and authentication​

  1. JWT: implementation of tokens in microservices

    JWT tokens: structure and usage

  2. OAuth2: authorization flow for API

    OAuth2: authorization principles

  3. Password hashing: modern security standards

    Password hashing: secure storage of credentials

  4. Secret management: Vault and analogues (overview)

12 tips for API security

Asynchrony and parallelism​

  1. Asynchronous programming: event loop and callbacks (concept and comparison with synchronous code)
  2. Multithreading vs Multiprocessing: Python specifics (concept and key differences)
  3. Python GIL: overview of the problem and approaches to bypass
  4. asyncio: basics of working with coroutines (practical examples of use)
  5. Background tasks: queues and scheduling (implementation via Celery/Redis)

Architectural patterns​

Architectural patterns
  1. Dependency Injection: Practical dependency injection (inversion of control)
  2. Factory pattern: Creating objects through factories (concept and comparison with other patterns)
  3. Singleton: Global resources and antipatterns (Overview for beginners)
  4. Data validation: Pydantic/Schema models (key libraries and approaches)
  5. Object serialization: JSON/Protobuf/MessagePack (formats and transmission optimization)
  6. API idempotency: Guarantee of single execution of operations

Additional topics​

  • Agile, Scrum, Kanban: basic development methodologies (concept and comparison)
  • Software Development Life Cycle (SDLC): development stages, planning, code review (Overview for beginners)
  • DevOps: basic principles and tools (Overview of key aspects)
  • Load Balancing: basic principles and tools (concept and comparison of approaches)

Silver​

System Design Fundamentals Playlist - by ByteByteGo

Silver videos

Extra Steps​

Extra Steps