• No hay productos en el carrito.

Inicio / Cursos / Understanding Node.js: Core Concepts
Impartido por Joseph HeidariPago único de $2,800 MXN · acceso por 12 meses

Understanding Node.js: Core Concepts

Understanding Node.js without any other NPM packages. Let's take your back-end engineering skills to the next level!

Certificado oficial emitido por la SEPA través del Gobierno del Estado de México
12 meses de acceso En línea · 60 h 13 unidades
Qué aprenderás

Lo que serás capaz de hacer

Welcome to the most comprehensive Node.js course on the internet! In this course, we're going to do a deep dive into Node.js itself without cluttering our minds with other tools and NPM packages and truly master this powerful technology. This course is heavily focused on computer science topics and fundamentals that are crucial to understand for becoming a great back-end engineer. You can only properly understand Node.js and unlock its full power if you understand these other computer science topics. So that's why we will also learn these other vital topics so that you can truly master Node.js and take your back-end engineering skills to a whole new level. We will also use all these vital concepts that we'll learn in practice by building various exciting projects just using Node.js . This is an intense course for people who want to get to the top of the field and get to a level of driving innovation and making an impact within the industry instead of just scratching the surface and following a few software trends and tools. Each section of the course is like its own mini-course, and by completing each section, you'll learn some essential Node.js, computer science and back-end engineering concepts that will help you not just if you want to use Node.js but throughout your whole career as a software engineer. These things will stay with you for years and decades to come. Let's do a quick walkthrough about what you will accomplish after completing some of the sections: Understanding Buffers : Here, we will deeply understand buffers and how to work directly with binary data, which is essential for all the other sections. Understanding File System : As a back-end developer, you'll work with files a lot, be it saving some data to disk, handling file uploads and many other examples, so it's essential to have a good understanding of them, which you'll gain after completing this section. We'll also learn how Node.js deals with files and master the "fs" module. Understanding Streams : In this section, we're going to master Streams, which will allow us to develop highly-performant apps capable of handling terabytes of data with ease while having great memory usage. We'll build many mini-projects throughout the section, including an encryption-decryption app from scratch that could encrypt terabytes of data by directly modifying the binary data. This section lays the foundation for future sections where we'll utilize Streams heavily to create powerful and efficient network applications. Understanding Networking : Node.js was primarily designed to create network applications, so it's of utmost importance that we gain a decent understanding of networking, which we will do after completing this section. Here's a list of items we'll learn in this section: What exactly a network is How the internet works Mac Addresses IPV4 & IPv6 Addresses TCP UDP DNS Fundamentals of deployment We'll build 2 low-level apps using only Node.js, a chat and a file uploader app directly on top of TCP! And then, we'll deploy them to a Linux server in the most basic way without using unnecessary tools. We'll see exactly what happens in our network card, every single 0s and 1s exchanged for a particular thing using Wireshark, and gain a much better understanding of networking and how most of the well-known protocols like HTTP, FTP, Email protocols, SSH, DNS and many others work. This section will broaden your horizons, and you'll realize that there are far more things that you can do with Node.js than just creating web servers. Understanding HTTP: In this section, we'll utilize and combine all that we've learned from previous sections and finally deeply understand HTTP once and for all! We won't be learning how to use Express; instead, we will build something similar ourselves! We'll start by understanding the most important HTTP concepts, such as connection types, client-server model, messages, requests, responses, HTTP Methods, status codes, mime types, necessary headers and so much more. And then emulate an HTTP protocol directly on top of TCP using the net module and see precisely every single 0s and 1s that get exchanged for an HTTP request and response interaction! Once we understand the fundamentals of HTTP and the "http" module, we'll take things to the next level and start building our framework. And then, using our framework, we'll make a fully functional web application. This section will take your web development skills to the next level. You'll have a much better understanding of how all these popular NPM packages, like Express, body-parser, Multer, cors, etc., that are built on top of the "http" module work. Well, you'll learn how to make them from scratch, just using them will not be that much of a problem! Update February 2024 - New Module Is Out! Understanding Unix : With over 15 hours of comprehensive new content, get ready to learn how you can harness the power of multiple technologies and programming languages together with Node.js to create extraordinarily powerful applications! Unix, one of the most influential inventions ever in the software industry, is crucial for software engineers to understand. In this module, we'll delve deep into some of the key concepts such as Bash, Shells, IPC, Data Streams, Process Management, Clustering, even some C and much more. We will also understand these Node.js modules: Child Processes Cluster Process Path Console OS All these Unix concepts that you'll learn in this section instantly apply to many other programming languages. You'll gain a foundation that you can keep building on to create much higher-quality applications than ever before. At the end of the section, we'll develop a video editing web application with Node.js without using other NPM packages. And this is just the beginning! You'll be able to do much more than this once you're done with the section and see many new possibilities that you never thought about before. Update May 2024 - New Module Is Out! Understanding Compression : In this section, we will explore the fascinating world of compression. Understanding compression is crucial for reducing the size of your data, and one important use case is to enhance the speed of your network applications. We'll dive into the Node.js Zlib module and see how it is possible to reduce the number of bits needed to store and transfer your data without losing any information! Update July 2024 - New Module Is Out! Understanding Multi-Threading : Get ready for the most advanced section of the course, where we're going to utilize the full power of Node.js to see how extreme we can get. We'll learn what exactly threads are and how to utilize them to achieve performance boosts up to many times, depending on how many CPU cores we have. We'll learn when we should use multi-threading and when we shouldn't. We'll learn how to set up communication channels between our threads, both with message passing and shared memory. We'll explore the Node.js thread pool and even develop one ourselves from scratch. We'll see how multi-threading differs in Node.js from some of the other languages. We'll cover synchronization, race conditions, deadlocks, semaphores, mutual exclusion and more. You'll learn how to keep the event loop light and not end up doing operations that will mysteriously block your main thread and cause your app to be way slower. This section will take your Node.js skills to the next level by teaching you how to run things in parallel, handle multiple event loops, and understand the complications that arise with that. Update March & August 2025 - New Module Is Out! Understanding Cryptography : In this section you’ll learn about one of the most fascinating topics in computer science, without which the digital world and the internet would be in absolute chaos, and almost anyone could access everything you have online or stored digitally offline. You’ll learn about some of the same cutting-edge cryptographic tools that governments and top companies rely on to protect their top-secret data and users online. You'll learn about AES, RSA, Diffie-Hellman, Elliptic-Curve Cryptography, HTTPS, TLS, Digital Signatures, Hashing algorithms, and more! This section will give you a strong foundation to start your journey of learning about cybersecurity. Learning cryptography is extremely important in today’s world, not only to be able to create secure software and protect your business and users, but also to help protect yourself in the digital world. Jump right in, and let’s explore the principles and techniques that are protecting our privacy, freedom of speech, and security in today’s massive digital world. Sign up today, and let's master Node.js and take your back-end engineering skills to a whole new level!

  • Learn some of the vital concepts of back-end engineering
  • Get to a level capable of easily learning various NodeJS frameworks and libraries
  • Truly and deeply understand what exactly NodeJS is and see its full potentials far beyond just creating web servers
  • Understand and master NodeJS as it is without using any other NPM packages
  • Understand some of the most important operating systems concepts that every back-end developer needs to understand
  • Be able to easily learn and understand the NodeJS documentation

Temario

UNIDAD 1 - Introduction · 7 lecciones

UNIDAD 1 - Introduction

  • Course OverviewVideo · 30 min
  • Setting Up - For Windows Users OnlyVideo · 50 min
  • Setting Up - For Mac Users OnlyVideo · 1 h
  • Setting Up - For Linux Users OnlyVideo · 53 min
  • Introduction to the Command LineVideo · 41 min
  • Learning NVM & Node.js VersionsVideo · 15 min
  • Node.js Under the HoodVideo · 1 h 36 min
UNIDAD 2 - Understanding EventEmitter · 2 lecciones

UNIDAD 2 - Understanding EventEmitter

  • Understanding EventEmitterVideo · 34 min
  • EventEmitter ObjectCuestionario · 0 min
UNIDAD 3 - Understanding Buffers · 11 lecciones

UNIDAD 3 - Understanding Buffers

  • IntrodcutionVideo · 7 min
  • Understanding Binary NumbersVideo · 14 min
  • Understanding Hexadecimal NumbersVideo · 21 min
  • Using a Programming CalculatorVideo · 12 min
  • Understanding Character EncodingsVideo · 25 min
  • The Concept of BuffersVideo · 8 min
  • Buffers in ActionVideo · 39 min
  • Allocating Huge BuffersVideo · 18 min
  • Fastest Way of Allocating BuffersVideo · 21 min
  • Reading the Node.js DocsVideo · 14 min
  • OutroVideo · 2 min
UNIDAD 4 - Understanding File System · 15 lecciones

UNIDAD 4 - Understanding File System

  • IntroductionVideo · 11 min
  • What Exactly Is a File?Video · 8 min
  • How Node.js Deals with FilesVideo · 4 min
  • Three Different Ways of Doing the Same ThingVideo · 15 min
  • Starting Point for Building Our ApplicationLectura · 0 min
  • Watching the Command File for ChangesVideo · 14 min
  • Reading the Content of the Command FileVideo · 19 min
  • Cleaning Up the Code using EventEmitterVideo · 4 min
  • Making Sense Out of the Read DataVideo · 4 min
  • Implementing the Create File CommandVideo · 16 min
  • Defining the Rest of the CommandsVideo · 15 min
  • Solution - Implementing the deleteFile FunctionVideo · 11 min
  • Solution - Implementing the renameFile FunctionVideo · 4 min
  • Solution - Implementing the addToFile FunctionVideo · 11 min
  • OutroVideo · 1 min
UNIDAD 5 - Understanding Streams · 19 lecciones

UNIDAD 5 - Understanding Streams

  • IntroductionVideo · 5 min
  • Benchmarking Writing a Million Times to a FileVideo · 26 min
  • Using Streams Naively in Our SolutionVideo · 8 min
  • So What Exactly Are Streams?Video · 9 min
  • Understanding Different Types of StreamsVideo · 18 min
  • Fixing the Memory Issue in Our ProgramVideo · 37 min
  • Reading Writable Streams Node.js Docs and RecapVideo · 10 min
  • Readable Streams in ActionVideo · 22 min
  • Selectively Writing Our Data from the Readable StreamVideo · 9 min
  • Understanding the Splitting IssueVideo · 17 min
  • Implementing the Solution and Resolving the Splitting IssueVideo · 16 min
  • Reading Node.js Docs and RecapVideo · 8 min
  • Building Our Own Streaming Solution Using BuffersVideo · 24 min
  • Understanding PipingVideo · 26 min
  • Implementing Our Own Writable StreamVideo · 42 min
  • Implementing Our Own Readable StreamVideo · 20 min
  • Understanding Duplex and Transform StreamsVideo · 17 min
  • Creating an Encryption/Decryption ApplicationVideo · 39 min
  • Final NotesVideo · 26 min
UNIDAD 6 - Understanding Networking · 31 lecciones

UNIDAD 6 - Understanding Networking

  • IntroductionVideo · 12 min
  • Understanding MAC Addresses and SwitchesVideo · 15 min
  • Understanding Routers and How the Internet WorksVideo · 15 min
  • Understanding Networking LayersVideo · 16 min
  • A Quick Tip About Filtering in WiresharkLectura · 0 min
  • Creating a Simple TCP Application in Node.jsVideo · 25 min
  • Understanding the Transport Layer - TCP/UDPVideo · 13 min
  • A Networking Scenario in ActionVideo · 25 min
  • Understanding Port NumbersVideo · 12 min
  • Starting Point for Building Our Chat AppLectura · 0 min
  • Creating a Chat Application PART 1Video · 30 min
  • Creating a Chat Application PART 2Video · 34 min
  • Improving the UI of our Chat AppVideo · 22 min
  • Identifying Users in the Chat AppVideo · 19 min
  • Notifying Everyone When Somebody Joins/Leaves the ChatVideo · 4 min
  • A Note About the 'end' Event on WindowsLectura · 0 min
  • Some Final Notes About the Chat AppVideo · 15 min
  • Deploying our Chat App to AWSVideo · 34 min
  • Commands Used for Installing NVMLectura · 0 min
  • Understanding IPv4 AddressesVideo · 40 min
  • Understanding DNSVideo · 32 min
  • Understanding IPv6 AddressesVideo · 27 min
  • Starting Point for Building Our Uploader AppLectura · 0 min
  • Creating an Uploader ApplicationVideo · 26 min
  • Taking Care of Backpressures in the Uploader AppVideo · 33 min
  • Getting the File Names Dynamically in the Uploader AppVideo · 21 min
  • Displaying the Upload Progress in Our Uploader AppVideo · 16 min
  • Deploying our Uploader AppVideo · 20 min
  • AWS Cost Warning - Server Termination ReminderLectura · 0 min
  • Understanding UDP and the Dgram ModuleVideo · 33 min
  • OutroVideo · 2 min
UNIDAD 7 - Understanding HTTP · 33 lecciones

UNIDAD 7 - Understanding HTTP

  • IntroductionVideo · 11 min
  • The Idea of HTTPVideo · 7 min
  • Creating a Simple HTTP Server in NodeVideo · 15 min
  • Understanding HTTP Messages, Requests & ResponsesVideo · 13 min
  • Understanding Connection TypesVideo · 16 min
  • Building our Client and Sending a RequestVideo · 21 min
  • Sending a Response to the ClientVideo · 13 min
  • Learning Postman & Testing Our Server with ItVideo · 26 min
  • Reading Some DocsVideo · 29 min
  • Sending an HTTP Request Directly on Top of TCP! PART 1Video · 20 min
  • Sending an HTTP Request Directly on Top of TCP! PART 2Video · 22 min
  • Emulating our HTTP Server Using the Net ModuleVideo · 11 min
  • Understanding Media Types (MIME Types)Video · 17 min
  • Understanding HTTP MethodsVideo · 22 min
  • Understanding HTTP status codesVideo · 15 min
  • Creating a Simple Web Server in NodeVideo · 18 min
  • Serving a CSS and JavaScript FileVideo · 22 min
  • Adding Some JSON RoutesVideo · 8 min
  • Adding a File Upload RouteVideo · 13 min
  • Creating our Own Little Mini-Express Framework!Video · 23 min
  • Making our Framework More RobustVideo · 15 min
  • Getting Ready for Our Next ProjectVideo · 11 min
  • Using Our Framework to Create a Web AppVideo · 16 min
  • Adding the Login RouteVideo · 21 min
  • Understanding HTTP ProxiesVideo · 18 min
  • HTTP is StatelessVideo · 13 min
  • Understanding CookiesVideo · 13 min
  • Recognizing Users for Future Requests after Logging InVideo · 18 min
  • Sending the User’s Info in ProfileVideo · 9 min
  • Enhancing Our Framework with Middleware SupportVideo · 23 min
  • Defining the Middleware FunctionsVideo · 18 min
  • Implementing the Create Post, Update User, and Logout RoutesVideo · 25 min
  • OutroVideo · 3 min
UNIDAD 8 - Understanding Unix · 42 lecciones

UNIDAD 8 - Understanding Unix

  • IntroductionVideo · 13 min
  • What Is Unix?Video · 11 min
  • Why Should We Care About Unix?Video · 5 min
  • Setting Up Unix on Windows (WSL) - For Windows Users OnlyVideo · 20 min
  • A First Look at the Child Process ModuleVideo · 16 min
  • Understanding Unix ShellsVideo · 40 min
  • Demystifying Bash Execution Order: Aliases, Functions, Built-ins, and PathVideo · 27 min
  • A Few Notes about Unix File PermissionsVideo · 14 min
  • Sourcing in BashVideo · 5 min
  • Understanding Shell Config FilesVideo · 38 min
  • What Exactly is a Child Process?Video · 24 min
  • Understanding Environment VariablesVideo · 14 min
  • Understanding Unix File System, Paths & CWDVideo · 49 min
  • Understanding Stdout, Stdin, and StderrVideo · 33 min
  • Understanding Pipes and Output Redirection in BashVideo · 12 min
  • Building a Command Line Utility with Node.jsVideo · 17 min
  • Building Massive Communication App - Node PartVideo · 18 min
  • Intro to the C PartVideo · 11 min
  • Learning C - Our First AppVideo · 13 min
  • Learning C - Static Types & Our MemoryVideo · 43 min
  • Learning C - Memory AllocationVideo · 31 min
  • Learning C - Reading the ArgumentsVideo · 5 min
  • Building Massive Communication App - C PartVideo · 51 min
  • Only Watch if You Skipped the C PartVideo · 10 min
  • Another Way of IPC - Unix Domain SocketsVideo · 21 min
  • Understanding ClusteringVideo · 33 min
  • Clustering in ActionVideo · 46 min
  • Installing & Building FFmpeg from Source CodeVideo · 12 min
  • Video Editor App - Setup & WalkthroughVideo · 38 min
  • Adding the Upload RouteVideo · 36 min
  • Quick Intro to FFmpeg and Video FilesVideo · 20 min
  • Making a Thumbnail and Getting the Dimensions After an UploadVideo · 25 min
  • Returning the List of Uploaded VideosVideo · 4 min
  • Adding a Route for Returning the Video AssetsVideo · 24 min
  • Adding a Route to Extract the Audio of a Video FileVideo · 16 min
  • Adding the Resize RouteVideo · 19 min
  • Scheduling the ResizesVideo · 25 min
  • More on Queue-based ProcessingVideo · 17 min
  • Resuming Scheduled Resize Operations Upon App RestartVideo · 19 min
  • Running Our Application in Cluster ModeVideo · 31 min
  • Refactor from Cpeak to Express in Less than 20 Minutes!Video · 8 min
  • OutroVideo · 23 min
UNIDAD 9 - Understanding Compression · 8 lecciones

UNIDAD 9 - Understanding Compression

  • IntroductionVideo · 24 min
  • How Does a Lossless Compression Work?Video · 30 min
  • Lossy CompressionVideo · 21 min
  • Gzip, Brotli and DeflateVideo · 31 min
  • Compression in HTTPVideo · 18 min
  • Compression vs. MinificationVideo · 6 min
  • Deploying Compression onto Our AppsVideo · 24 min
  • Final NotesVideo · 12 min
UNIDAD 10 - Understanding Multi-Threading · 31 lecciones

UNIDAD 10 - Understanding Multi-Threading

  • IntroductionVideo · 12 min
  • Guide for Skilled Multi-Threaded DevelopersVideo · 11 min
  • What Exactly Is a Thread?Video · 40 min
  • How to Monitor Threads on Your Operating SystemVideo · 8 min
  • Understanding CPU UsageVideo · 9 min
  • Spawning ThreadsVideo · 23 min
  • Thread Communication through Message-PassingVideo · 33 min
  • Introduction to Our CPU-Intensive ProgramVideo · 12 min
  • Enhancing Performance with Multi-ThreadingVideo · 23 min
  • Handling CPU-Intensive Operations in an HTTP ServerVideo · 31 min
  • isMainThreadVideo · 6 min
  • CPU-Intensive vs. I/O-IntensiveVideo · 11 min
  • Examining a Crypto-Heavy Multi-Threaded AppVideo · 19 min
  • Node.js Thread PoolVideo · 18 min
  • Developing a Thread Pool From ScratchVideo · 31 min
  • Event Loop Utilization and Main ThreadVideo · 12 min
  • Keep the Main Thread Light with Batch ProcessingVideo · 22 min
  • Effortlessly Expanding Our Thread Pool CapabilitiesVideo · 6 min
  • Don’t Block the Worker Pool!Video · 8 min
  • Handling Billions of HTTP RequestsVideo · 35 min
  • Communication Through Shared MemoryVideo · 19 min
  • ArrayBuffers, SharedArrayBuffers, and TypedArraysVideo · 17 min
  • Race ConditionsVideo · 17 min
  • Understanding Atomic OperationsVideo · 18 min
  • Understanding Mutual ExclusionVideo · 23 min
  • DeadlocksVideo · 21 min
  • Enhancing Performance Through Shared MemoryVideo · 21 min
  • Native Multi-Threading with C/C++ AddonsVideo · 44 min
  • A Deeper Look at the Event Loop PART 1Video · 37 min
  • A Deeper Look at the Event Loop PART 2Video · 34 min
  • OutroVideo · 3 min
UNIDAD 11 - Understanding Cryptography · 30 lecciones

UNIDAD 11 - Understanding Cryptography

  • IntroductionVideo · 40 min
  • Introduction to Symmetric EncryptionVideo · 12 min
  • The Unbreakable Encryption - OTP From ScratchVideo · 27 min
  • How AES Encryption WorksVideo · 32 min
  • Understanding AES ModesVideo · 43 min
  • What It Takes to Break AESVideo · 17 min
  • What About Brute-Forcing OTP?Video · 7 min
  • History of AESVideo · 8 min
  • Understanding HashingVideo · 44 min
  • SHA-256 From ScratchVideo · 11 min
  • What It Takes to Break SHA-256Video · 22 min
  • Message Authentication CodesVideo · 30 min
  • Understanding Key Derivation FunctionsVideo · 24 min
  • Building a File Encryption ApplicationVideo · 40 min
  • Introduction to Asymmetric CryptographyVideo · 17 min
  • A Note about OpenSSL & SetupVideo · 8 min
  • The New Cheat Sheet FileLectura · 0 min
  • RSA in ActionVideo · 29 min
  • Understanding RSAVideo · 33 min
  • Implementing RSA From ScratchVideo · 34 min
  • Understanding Digital SignaturesVideo · 18 min
  • Digital CertificatesVideo · 25 min
  • Manually Verifying an HTTPS CertificateVideo · 28 min
  • Setting Up HTTPS from ScratchVideo · 33 min
  • Understanding TLSVideo · 40 min
  • Diffie-Hellman and Elliptic Curve Key ExchangeVideo · 32 min
  • Elliptic Curve Digital SignaturesVideo · 18 min
  • RSA, DH and EC SecurityVideo · 12 min
  • Legal Battles over CryptographyLectura · 0 min
  • OutroVideo · 11 min
UNIDAD 12 - Security · 3 lecciones

UNIDAD 12 - Security

  • IntroductionLectura · 0 min
  • How to Securely Store User PasswordsVideo · 29 min
  • More Lectures on the WayLectura · 0 min
UNIDAD 13 - Extra · 1 lecciones

UNIDAD 13 - Extra

  • Handling 1 Million HTTP Requests per SecondLectura · 0 min
Certificado oficial

Tu certificado lo emite la SEP, no solo una plataforma

Al demostrar la competencia recibes un certificado emitido por la Secretaría de Educación Pública a través del Gobierno del Estado de México: un documento oficial que puedes presentar con confianza ante cualquier empleador o institución.

Tu certificado con INEC

  • Lo emite la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México
  • Documento oficial con folio verificable en línea
  • Lo otorga la Universidad Tecnológica Fidel Velázquez

Otras plataformas en línea

  • Constancia privada emitida por la misma plataforma
  • Solo acredita horas cursadas o asistencia
  • Sin respaldo de una autoridad educativa
Cómo funciona

Tu itinerario, de la inscripción al certificado

  1. 1

    Inscripción con pago único

    Pagas $2,800 MXN una sola vez y entras de inmediato al curso.

  2. 2

    Estudias a tu ritmo

    13 unidades con videos, lecturas y actividades, disponibles 24/7 durante 12 meses.

  3. 3

    Cuestionarios por unidad

    1 cuestionarios para comprobar lo aprendido.

  4. 4

    Certificado

    Emitido por la SEP a través del Gobierno del Estado de México, con folio verificable.

Lo que obtienes

Un certificado oficial de la SEP

Muestra del certificado: Understanding Node.js: Core Concepts

Muestra · verificable por folio y QR

  • Emitido por la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México. No es una constancia privada: es un documento oficial, y ese respaldo marca la diferencia frente a otras plataformas en línea.
  • Contenido impartido por Joseph Heidari.
  • Folio y QR verificables para compartirlo con quien te contrate.
Medios que necesitas
Equipo de cómputo Conexión estable a internet
Pago único

Empieza hoy, a tu ritmo

Un solo pago y acceso inmediato al curso completo durante 12 meses.

  • 13 unidades · 233 lecciones · 60 h
  • 12 meses de acceso
  • 1 cuestionarios de evaluación
  • Certificado emitido por la SEP (Gob. del Estado de México) con folio verificable
Pago único
$2,800MXN
Acceso por 12 meses
Inscribirme Hablar con un asesor
Preguntas frecuentes

Sobre tu inscripción

¿Cómo es el pago?

Un solo pago de $2,800 MXN. No hay mensualidades ni cargos recurrentes.

¿Cuánto tiempo tengo acceso?

12 meses desde tu inscripción, 24/7, para avanzar a tu ritmo.

¿Quién imparte el contenido?

El curso es impartido por Joseph Heidari; INEC gestiona tu inscripción, evaluación y certificado.

¿Qué pasa cuando vence mi acceso?

Puedes renovar tu cuenta tú mismo desde la plataforma, sin trámites ni esperas.

Certificado emitido por la SEP a través del Gobierno del Estado de México · Understanding Node.js: Core Concepts

Inscribirme
  INEC es una Marca de SalesPartners Ciudad de México S de RL de CV. Template Design © Learnify LMS. All rights reserved. Terminos y Condiciones Aviso de Privacidad Politica de Devolución
Hide picture