00:00:00
Learning to code was enough 5 years ago,
00:00:02
but it's not anymore. In 2025, you need
00:00:05
more than just typing Python into a
00:00:07
keyboard. And if you don't master these
00:00:09
five skills, then you'll be left behind,
00:00:11
plain and simple. Now, look, I'm not
00:00:14
here to motivate you. I'm here to give
00:00:15
you a road map. I'll tell you exactly
00:00:17
what you need to learn for each skill so
00:00:19
you can actually do something about it.
00:00:21
And by the way, if you want one-on-one
00:00:23
advice for your exact situation, I've
00:00:25
got something launching soon, which you
00:00:27
can read more about from the link in the
00:00:28
description. We're only taking 20
00:00:30
students, so jump on the wait list if
00:00:32
you want a chance to join. With that
00:00:34
said, let's get into skill number one,
00:00:36
which is systems thinking. Now, most
00:00:38
beginner developers only think in terms
00:00:40
of the code. They're focused on things
00:00:42
like files, functions, or classes, but
00:00:44
they ignore the entire system as a
00:00:47
whole. Now, as you get more experienced,
00:00:49
you start to think more like a systems
00:00:50
engineer or a systems architect, where
00:00:53
you consider the entire system, not just
00:00:55
all of the individual lines of code. So
00:00:58
what I mean by this is thinking of a
00:00:59
system like having a front end, a
00:01:01
backend, an API, a database, maybe a
00:01:04
queue or some kind of cache that's going
00:01:06
on. Understanding how the data flows
00:01:08
between those various components, and
00:01:10
then looking at things like asynchronous
00:01:12
programming or synchronous programming,
00:01:13
how to handle various requests, how to
00:01:15
potentially scale the system up using
00:01:17
something like vertical scaling or
00:01:19
horizontal scaling. These are the topics
00:01:21
that I'm talking about here. And in
00:01:23
order to really get to the next level,
00:01:25
you need to start understanding some
00:01:26
basic system design concepts. So what I
00:01:29
have for you here is a quick list of
00:01:30
tools and kind of resources or topics
00:01:32
that you'd want to be aware of. So let
00:01:34
me list these out. So first we have
00:01:36
readies. Now this is a great tool for
00:01:38
caching and I definitely recommend using
00:01:39
it. Doesn't take too long to spin up and
00:01:41
to learn. Next, for things like task
00:01:43
cues, I'd look at something like Rabbit
00:01:45
MQ or Kafka. And then I'd want to be
00:01:48
looking into load balancing strategies
00:01:49
and using proxies or things like
00:01:51
EngineX. And then lastly, here's a few
00:01:53
terms that you should be aware of. So
00:01:55
things like throughput, latency, rate
00:01:58
limiting, connection pools, and read
00:02:00
replicas. Obviously, there's a lot more
00:02:02
stuff that I could put here, but
00:02:04
generally speaking, you want to start
00:02:05
thinking about a system as a whole,
00:02:07
breaking it into its various components,
00:02:09
and really understanding how the data
00:02:11
flows between those components. then you
00:02:13
can start thinking more about
00:02:14
scalability and some of the other skills
00:02:16
on this list will help you with that.
00:02:18
Now, if you did want to master this
00:02:19
particular skill, here's a great project
00:02:21
that you could work on that would cover
00:02:22
almost all of these areas. Now, that
00:02:24
project is to build a messaging app so
00:02:26
you can cache, for example, the 50
00:02:28
latest messages per user. You can set up
00:02:31
a queue like Rabbit MQ to handle email
00:02:33
notifications or offload those. And then
00:02:36
you have to deal with multiple messages
00:02:37
coming in at once, maybe connecting
00:02:39
different users to each other in private
00:02:41
rooms. How will this scale? If you have
00:02:43
users that are sending thousands of
00:02:45
different requests, maybe you want to
00:02:46
set up some kind of rate limit. You get
00:02:48
the idea. A message app is a great way
00:02:50
to get started building this skill. And
00:02:52
I'd recommend that you try it out. But
00:02:53
now, let's move on to skill number two.
00:02:56
But first, I want to be real with you.
00:02:58
These skills will all generally help
00:02:59
you, but each of your situations are
00:03:01
different and require a different
00:03:03
strategy, especially if you want to land
00:03:04
a job. Now, that's why I'm relaunching
00:03:07
my mentorship program, Dev Launch, in
00:03:09
just 2 weeks from now. Now, if you're
00:03:10
interested, sign up from the link below
00:03:12
to get notified when we go live, as I'm
00:03:14
only going to be accepting the top 20
00:03:16
applicants. Now, this program is
00:03:18
designed to help you launch your dev
00:03:20
career, and I've teamed up with senior
00:03:22
level software engineers from companies
00:03:23
like Google to give a small group of
00:03:25
students personalized advice and
00:03:27
assistance over a 4month period. Now,
00:03:30
you can register for the weight list
00:03:31
down below. And as a bonus, I'll even
00:03:33
send you a proven resume template that
00:03:35
has landed hundreds of interviews for
00:03:37
various students. Anyways, let's get
00:03:39
into skill number two, which is prompt
00:03:42
engineering and AI orchestration. Now,
00:03:44
look, we're in the age of AI now.
00:03:46
Obviously, it's important to understand
00:03:48
how LLMs work and also how you can use
00:03:50
them to build various applications. So,
00:03:52
in this skill here, yes, I'm talking
00:03:54
about utilizing LLMs for things like
00:03:56
coding, but also how you can use them
00:03:58
for building applications and tie them
00:04:00
into your apps. So, let me go over a few
00:04:02
topics that you'll want to be aware of.
00:04:04
Now number one is prompt chaining or
00:04:07
multi-step workflows. Next is token
00:04:09
limits and the context window for LLMs.
00:04:12
Then we have system prompts verse user
00:04:14
prompts and how to utilize those
00:04:16
properly. And then memory strategies
00:04:18
like using lang chain memory or vector
00:04:20
memory or various vector databases. Next
00:04:23
we have rag or retrieval augmented
00:04:25
generation to fetch data before you
00:04:27
prompt and kind of inject that inside of
00:04:30
the LLM. Now, in terms of learning these
00:04:32
topics and actually using them in an
00:04:34
app, I have a few tools that you may
00:04:35
consider learning. So, first, in terms
00:04:37
of some highlevel frameworks, you're
00:04:39
going to be wanting to use things like
00:04:40
Langchain, O Lama, and Llama Index. You
00:04:43
also could use something like Langraph,
00:04:45
for example, for a more advanced AI
00:04:47
application. Then, you want to learn
00:04:48
about various LLMs. So, obviously things
00:04:51
like OpenAI or GPT, Claude, Gemini,
00:04:54
Grock, DeepSeek. You don't need to know
00:04:56
them all, but you should be aware of
00:04:57
which LLM is best for which task and
00:05:00
know when to choose which one. Then
00:05:02
you're going to want to learn about
00:05:03
things like vector databases. So things
00:05:05
like Chroma DB or using something like
00:05:07
Astro DB. There's all kinds of different
00:05:09
vector databases out there. You should
00:05:11
learn at least one and actually build a
00:05:13
project around that. Now, in terms of a
00:05:15
simple project that you could work on to
00:05:17
learn some of these skills, I'd
00:05:18
recommend just making a simple document
00:05:20
question and answer bot. This means
00:05:22
you're going to have some kind of LLM.
00:05:24
You're going to load in some kind of PDF
00:05:26
or some kind of documents. You're going
00:05:27
to split those or chunk them up, store
00:05:29
them in a vector database, and then
00:05:31
you're going to have the LLM be able to
00:05:32
use this vector database using something
00:05:34
called rag retrieval augmented
00:05:36
generation to pull in relevant context
00:05:39
and then answer your question. So, for
00:05:40
example, you may have some information
00:05:42
about a restaurant like the menu. You
00:05:44
give the LM access to that document or
00:05:46
to the vector database that stores it
00:05:48
and then you can ask questions about the
00:05:49
menu and it can read that document and
00:05:51
actually reply to you with contextually
00:05:53
relevant responses. All right, that's
00:05:55
skill number two. Let's move on to skill
00:05:57
number three. All right, so the next
00:05:59
skill on my list here is endtoend
00:06:01
shipping or deployment. Essentially
00:06:03
going from code to the cloud and
00:06:05
actually allowing people to use your
00:06:06
applications. Now, most developers
00:06:08
actually never deploy something. They
00:06:10
simply write the code, it works on their
00:06:12
own machine, and then they stop there.
00:06:14
Now, that's fine in a lot of situations,
00:06:16
but if you really want to get to that
00:06:17
next level, you need to understand all
00:06:19
of the topics related to deployment
00:06:21
because really, this is a whole job on
00:06:23
its own. And there's so much you can
00:06:25
learn here and add a lot of value to
00:06:27
particular roles or organizations that
00:06:29
you join. So, let's go over a few topics
00:06:30
that you definitely want to learn. Now,
00:06:32
first is Docker and containerization.
00:06:35
How do you take large applications,
00:06:37
split them into smaller containers, and
00:06:39
how do you actually run those using
00:06:40
tools like Docker? Next, things like
00:06:42
GitHub actions. This can do automatic
00:06:45
deployment or automatic testing for you.
00:06:47
It's relatively simple, but allows you
00:06:49
to run some kind of scripts whenever
00:06:51
something changes in your GitHub
00:06:52
repository. Great if you want to
00:06:54
automatically deploy something on a
00:06:55
particular branch. Next, something like
00:06:58
secret management. So, how do you manage
00:06:59
environment variables? How do you do
00:07:01
that in the cloud? How do you deal with
00:07:03
various keys, permissions, and access?
00:07:06
Obviously, very, very important. Next,
00:07:08
you need monitoring and alerting. So, of
00:07:10
course, if something goes wrong in your
00:07:11
application, you need to be aware of
00:07:13
that, and you need a way to monitor
00:07:14
what's going on on local host or when
00:07:17
you're running it on your own computer.
00:07:18
Sure, you can look in the terminal and
00:07:20
you can view some basic debug
00:07:21
information, but when something's
00:07:23
deployed out to the cloud, it can be a
00:07:24
lot more difficult to do that. So, you
00:07:26
want to understand how do you monitor
00:07:28
your app? How do you deal with logs?
00:07:30
That's an important topic. Next, things
00:07:32
like roll back and recovery. So, how do
00:07:34
we take maybe a database in a corrupt
00:07:36
state and bring it back to something
00:07:37
that is proper? So, how do we roll
00:07:39
something back or recover data? Now, a
00:07:42
lot of this would be the role of a
00:07:43
DevOps engineer, but it's still a good
00:07:45
thing to be aware of and can definitely
00:07:47
make you more valuable again, especially
00:07:49
if you're looking for a job. Now, in
00:07:50
terms of specific tools and topics, of
00:07:52
course, like I mentioned, Docker, also
00:07:54
something like Kubernetes in terms of
00:07:56
orchestrating your Docker containers.
00:07:58
Then, we have things like GitHub
00:08:00
actions. Again, we already talked about
00:08:01
this, but understanding how to actually
00:08:03
write out those scripts. Then there's
00:08:05
tools like Versel and Render if you want
00:08:07
to actually deploy something out. And
00:08:09
then we have tools for logging like
00:08:11
Century or Log Rocket or Graphana. You
00:08:14
don't need to learn them all. Just want
00:08:15
to share a few with you here so you have
00:08:17
some ideas of where you can get started.
00:08:19
Now, in terms of projects that would
00:08:20
help you to learn this skill, let me go
00:08:22
over one that I think would be great.
00:08:24
Now, this is to build a URL shortener.
00:08:26
something like tiny URL where you paste
00:08:28
in some long URL and then can make a
00:08:30
shorter version of it and then whenever
00:08:32
you go to that short URL it redirects
00:08:34
you to the longer URL. This is actually
00:08:36
more complicated than it seems. And if
00:08:38
you really think about kind of the
00:08:39
design and architecture of this, you'll
00:08:41
realize what goes into this and how you
00:08:43
need to use some of these skills. So for
00:08:45
example, for the back end, you could
00:08:47
containerize this with Docker. You could
00:08:49
have the front end deployed on Verscell.
00:08:51
You could write some GitHub action
00:08:52
scripts to automatically test what's
00:08:54
going on. And then you could use some
00:08:55
monitoring and logging tools to actually
00:08:57
track all of the URLs that are being
00:08:59
generated and to make sure those are
00:09:00
working properly. Anyways, that is skill
00:09:03
number three. Let's move on to skill
00:09:05
number four. So skill number four is API
00:09:07
integration and design. Now most people
00:09:10
know how to use APIs by like calling
00:09:12
them for example, but they don't really
00:09:13
know how to design them, especially at
00:09:15
scale for other people to use. So that's
00:09:18
really what I'm talking about here,
00:09:19
understanding how to design APIs, some
00:09:22
of the best practices, and some of the
00:09:23
topics that I'm about to go through.
00:09:25
Now, first you want to understand REST
00:09:27
versus GraphQL. You then want to
00:09:29
understand how to name your APIs,
00:09:31
version, use various HTTP status codes,
00:09:34
and make sure that it's actually
00:09:36
reliable and that other people can use
00:09:38
it. Then you need to have authentication
00:09:40
and authorization. Of course, we don't
00:09:42
want anyone to just be able to use our
00:09:43
API. So, we need to understand how to
00:09:45
register API keys, for example, or how
00:09:47
to use various other methods like JWT
00:09:50
tokens or maybe something like OOTH 2.
00:09:53
Next, we want to talk about page nation
00:09:55
rate limiting or back off and retries.
00:09:57
Obviously, when you're using an API, you
00:09:59
don't want someone to just be able to
00:10:00
send massive amounts of requests. That's
00:10:02
where rate limiting comes in. And a lot
00:10:04
of times, if you're returning a bunch of
00:10:05
data, you want to pagionate that data so
00:10:07
you don't have these massive requests.
00:10:09
and you can send maybe 50 results at a
00:10:11
time rather than 5,000. Now, in terms of
00:10:14
actually applying these concepts, here's
00:10:15
a few tools that you might want to check
00:10:17
out. Of course, there's so many
00:10:19
different ways to build APIs, but here's
00:10:20
what I typically use and what I think is
00:10:22
pretty good for beginners to get started
00:10:24
with. Now, if you want to build APIs,
00:10:25
you can do that with something like fast
00:10:27
API Express. If you want to work in
00:10:29
something like JavaScript, you can do
00:10:30
that with the Django REST framework. And
00:10:32
again, I'm very kind of Pythonheavy
00:10:34
because that's what my channel focuses
00:10:36
on. But of course you can build APIs in
00:10:38
something like Go using the Jin
00:10:39
framework. You can build them in C++.
00:10:41
You can build them in all kinds of
00:10:42
different languages. But the point is
00:10:44
you want to have experience actually
00:10:45
building APIs. Next, you want to
00:10:47
understand how to test API. So using
00:10:49
something like Postman, for example, for
00:10:51
sending various requests, and then I'd
00:10:53
recommend looking into some APIs like
00:10:55
Stripe for payment processing, using the
00:10:58
OpenAI API, using the GitHub API and
00:11:01
being familiar with actually using a lot
00:11:02
of APIs because the more APIs that you
00:11:05
use, the more you understand how they're
00:11:07
designed, and then you can take those
00:11:08
principles and apply them to your own
00:11:10
APIs. And here's a project that you
00:11:12
could work on that would help you do
00:11:13
this. Now, this is essentially a backend
00:11:15
API for wrapping something like GPT or
00:11:18
some LLM call. Now, a lot of websites
00:11:20
now you can use some LLM on them, but of
00:11:23
course that's going to cost a lot of
00:11:24
money. So, they want to be able to, for
00:11:26
example, charge users. So, you should
00:11:28
set up the exact same thing. Create an
00:11:30
API, so a backend API, whatever
00:11:32
framework that you want, allow users to
00:11:34
authenticate themselves using either JWT
00:11:36
tokens or something like OOTH, and then
00:11:39
allow them to invoke an API. So call
00:11:41
something like the OpenAI API, but every
00:11:43
single time they do that or if they're
00:11:46
going to be doing it a lot, charge them
00:11:47
using Stripe. So for example, you can
00:11:50
have the Stripe API set up. You can
00:11:52
charge them maybe $5 to buy a bunch of
00:11:54
credits and then they can use those
00:11:55
credits when they call this LLM and then
00:11:57
they obviously recharge it by buying
00:11:59
more. I'm just giving you a simple
00:12:00
example here so that you could use
00:12:02
various APIs while building your own API
00:12:04
and actually providing a real service.
00:12:06
Anyways, that is skill number four.
00:12:08
Let's move on to number five. Now, the
00:12:10
next skill on my list here is a pretty
00:12:12
common one, but this is debugging. Now,
00:12:14
in the age of AI, I feel like a lot of
00:12:16
developers have lost this skill, and
00:12:18
that's why I'm putting it here. So, if
00:12:19
you want to seriously level up as a
00:12:21
developer, you need to get good at
00:12:22
debugging. It's not just about fixing
00:12:25
errors. It's about knowing how to
00:12:26
approach the unknown. So, you can start
00:12:28
by learning how to read a stack trace.
00:12:30
This tells you where your code crashed
00:12:32
and why. Now, don't just glance at it.
00:12:34
Read it line by line. Follow the trace,
00:12:36
and figure out where and why things went
00:12:39
wrong. Next, you can understand
00:12:40
techniques like binary search debugging.
00:12:42
This means strategically placing break
00:12:44
points or print statements to narrow
00:12:46
down where a bug is happening, like a
00:12:48
binary search for the faulty line of
00:12:50
code. This is fast, effective, and
00:12:52
critical when you're dealing with
00:12:54
complex systems. Then you can get
00:12:56
familiar with logs, metrics, and error
00:12:58
tracking tools. Logging helps you
00:13:00
reconstruct what your app was doing when
00:13:02
it failed. And tools like Century or Log
00:13:05
Rocket automatically surface exceptions
00:13:07
and show you the full context. Now, for
00:13:09
performance issues, you'll want to look
00:13:11
at how to use things like profiles and
00:13:13
system monitors. Now, you also need to
00:13:15
know the common types of bugs that
00:13:17
plague real systems. for example, no
00:13:19
references, race conditions, memory
00:13:22
leaks, off by one errors, and you should
00:13:24
know what they look like, how they
00:13:26
happen, and how you can prevent or debug
00:13:28
them. Now, here's a quick tool set that
00:13:31
you might want to master to make you
00:13:32
good at debugging. First, code level
00:13:34
debugging. So using things like VS Code
00:13:36
debugger, PDB in Python, Chrome Dev
00:13:39
Tools if you're debugging, you know,
00:13:41
React or something like JavaScript,
00:13:43
error tracing with Century, Log Rocket
00:13:45
or something like Rollbar, and then
00:13:47
profiling and performance using
00:13:48
something like Cprofile, Pispy, the
00:13:51
Chrome performance tab. There's all
00:13:53
kinds of profilers based on the language
00:13:55
and framework that you're using. So next
00:13:57
we have system level debugging. So using
00:13:59
commands like top or htop and various
00:14:01
Linux commands so you can actually
00:14:03
inspect and see what's going on in the
00:14:05
system with processes with the memory
00:14:08
the different file handles. That's
00:14:10
important as well. You're not just
00:14:11
debugging code. Sometimes you need to
00:14:12
debug the system to see what's actually
00:14:15
going wrong. Now this isn't just about
00:14:17
knowing the tools. It's about building
00:14:19
the mindset to diagnose and fix
00:14:21
anything. That's really what good
00:14:22
developers do right now. Generally, the
00:14:25
faster and better you get at debugging,
00:14:26
the faster you're going to become at
00:14:28
shipping production grade code, which is
00:14:30
really what matters for most people and
00:14:32
most organizations. Now, look, there's
00:14:34
all kinds of ways to learn how to debug,
00:14:35
but generally, you just need to write a
00:14:37
lot of code and also have that mindset
00:14:39
that you're going to go in there and fix
00:14:41
it and not just give up whenever a bug
00:14:43
occurs. Read through your error
00:14:44
messages, use all of the tools and
00:14:46
resources that you have, and practice
00:14:48
doing this on a daily basis so that you
00:14:49
actually get good at it. So, there you
00:14:51
go, guys. That is this video. Those are
00:14:53
the five skills that I think you should
00:14:55
add that are not just coding. Let me
00:14:57
know if you agree with me in the
00:14:59
comments down below and I look forward
00:15:00
to seeing you in another video.
00:15:03
[Music]
