Trainee

Junior
Backend
Junior Advanced
SSR
SR

DNS Hosting

What is
Internet Domain Name
HTTP?

Relational PostgreSQL
DB

MongoDB InfluxDB
NoSQL DB

Cassandra Redis

N+1 Problem

ORMs

Normalizacion
ACID
More about
DB Failures Modes
Transactions

Profiling
Performance
 Data
DB Indexes Scaling DBs
Replication

Basic
Terminal
Commands

How OSs
work in
Basic
general
Networking
Communcation
Memory
Operating Management
Threads and
Systems
Concurrency
Knowledge Interprocess
Process Communication
Management
I/O
Management

Trello

Git
Postman Tools

Browser Dev
YouTrack Tools

Linters ESLint
 npm scripts Task Runners pnpm/yarn

JWT
Token Auth
GraphQL
Cookie Based

REST APIs gRPC

JSON APIs

SAML
OAuth2

scrypt
CORS
SHA
Web Security
HTTPS
Knowledge
bcrypt
CSP

OWASP Risks

Integration
Testing Unit Testing
Testing

Web Sockets
Progressive
SSR and Server
Web Apps
Sent Events
 UML
Monolithic
Apps
Architectural System
& Design Analisys
Microservices
Coupling and
Cohesion

Redis Caching CDN

Docker Container
Docker & Kubernetes
Compose Virtualizacion

DDD
TDD
Event
Semantic Sourcing
Version
SOLID Create NPM
Design Package GOF
Principles
DRY Software Design
Design Patterns
Clean Code PoSA
YAGNI Create
documentation
CQRS
 Interfaces Abstraction

Abstract Class Encapsulation

Concrete OOP
Polymorphism
Class

Scope /
Inheritance
Visibilty

Minimize
HTTP
Request

Non Blocking Minified if and

JS Performance
iterations

Gzip / Brotli
compression
 Javascript
var
Variable Variable
let
Naming Rules Declarations
const
Trainee
Junior
What is JS?
Junior Advanced
Basics Hoisting
How to run
JS?
Block
Variable
Function
Scopes
Global
string
undefined
number Object
bigint Data Types
boolean typeof
null operator

Symbol

Explicit Type
Type Casting
Type Casting
conversion
Implicit Type
Casting
Coersion

Structured
Data / JSON
Map
Weak Map Data
Array BufferArray
Set Structures
Weak Set

==
Equality
===
Comparisons
Object.is

for
throw do ... while
Exception Control
try / catch / finally while
Handling Structures
Error objects if ... else
swith ... case
Assignment Default
Parameters
Arithmetic
Comparison
Logical
Arrow Rest
String Expressions
Conditional and Functions
Comma Operators
IIFEs
Unary Recursion
Bitwise Scope &
BigInt Function
Relational Stack Lexical
Scoping

Callbacks Callback Hell

setTimeout Asyncronous
setInterval JS
Promises
async / await

Promise.race Promise.all
Promise.any Promise.resolve
Promise.allSetled Promise.reject

Memory Memory Garbage

Lifecycle Management Collection
 Typescript
Trainee What is TS?
Junior tsc
Junior Advanced
Installation /
Basics
Configuration
ts-node

tsconfig.json
compiler options
boolean
number
Tuple string
enum void
interface undefined
Types
null
any
unknown
never object
class
arrays

Union
Intersection Combining
Predicates
Aliases Types
keyof operator

Declaration
types vs
Interfaces Extending
interfaces
Hybrid types

Constructor Params
Access Modifiers
Abstract Classes
Classes Inheritance
Polymorphism
Method Overriding

Generic
Generics Generic Types
Constraints

Custom
Decoratos
Decorators

Partial
Pick
Exclude
Utility Types Omit
Extract
Readonly
Record
 Docker

Trainee
Junior Basic Containers
Junior Advanced Dockerfile
Basics
Image OCI
Container

Docker Hub

Package Manager
Users / Groups Permissions Linux
Shell Commands Fundamentals
Shell Scripting

Data Volume Mounts

filesystem
Persistence Bind Mounts

docker compose
and docker basics
commands

Eficient layer caching Building

Image size
and security

CI/CD

Hot Reloading Experience

createMutable
modifyMutable

PaaS Options Kubernetes

Deploying
Containers
Nomad Docker Swarm