Transcript
If you're trying to break into tech right now, you've probably noticed a frustrating problem. Tutorials teach you how to write code, but that's honestly the easy part. When you get hired, you aren't just a solo coder anymore. You have to integrate with a team, existing code, and moving parts. You're thrown into a world of Jira tickets, Git repositories, staging environments, and deployment pipelines. It's incredibly overwhelming. Most people only understand this stuff after 6 to 12 months on the job. And honestly, most beginners get massive imposter syndrome their first week because no one taught them this stuff.
Most of that only comes from years on the job. This course hands you the short version. So when you talk about it, you sound like someone who already has the experience well before you've actually put in the time. This course exists to fix that. In under 2 hours, we are going to walk through the real-world developer workflow. We're not going deep into theory. The focus is how things actually work in real jobs. No dry history lessons on hardware, just the day-to-day reality of modern IT. We're going to look at how front ends and back ends actually talk to each other using APIs, how to navigate code reviews and Q&A pushback without taking it personally, how to read a status code and a log line so you can tell where a problem is before anyone else, how cloud platforms like AWS actually fit into the picture, and how developers are actually using AI tools like Copilot and Cursor today, including how to review what the AI hands you because that's the skill that actually gets you trusted.
If you want to stop feeling lost in tech jargon and actually understand how the industry operates, this is for you. If this is the part you've been missing, you'll get a lot out of this. Welcome to module one. It's a short one with two ideas. We'll look at what IT covers inside a real company using one everyday example. You'll also see the two reasons depend on these systems, including companies that don't sell software at all. By the end of this module, you'll be able to explain what IT really is and why a business can't run without it. Ask 10 people what IT means and you'll get 10 different answers.
Some think it's the guy who fixes your laptop. Some think it's just coding. Neither one is really the full picture. In real companies, IT is every system that keeps the business running digitally. That includes the app your customers use, the servers that host it, the database that stores their information, the network that connects everything, and yes, the person who resets your password when you forget it. Think about ordering food from an app. The moment you tap order, you've triggered a whole chain of IT systems. The app talks to a server. The server checks a database to confirm the restaurant is open.
Another system calculates your delivery fee. A notification system pings the driver. All of that from end to end is IT. So when people say they work in IT, that could mean building the app, maintaining the servers, securing the data, or supporting the people who use all of it. It's not one job. It's an entire ecosystem of jobs working together. And here's the part most beginners miss. None of these systems exist in isolation. They're all built and maintained by teams of people who have to coordinate constantly. Which brings us to the next question. How do companies actually organize all of this?
Here's something that surprises a lot of beginners. Most companies aren't in the business of making software. A bank isn't a software company. A hospital isn't a software company. But almost every single one of them runs entirely on software. Companies use IT for two big reasons. First, to run the business internally. Things like payroll systems, internal messaging tools, and databases that track inventory or employees. Second, to serve customers externally, things like a banking app, a hospital's patient portal, or an online store. Companies organize all of this in different ways, and we'll talk about what that means for your first job near the end of the course.
In either case, IT isn't a side department anymore. It's the backbone. If the systems go down, the company stops making money, customers can't get service, and employees can't do their jobs. That's why companies invest so heavily in the people and processes that keep IT running smoothly. Now that you understand what IT is and how companies rely on it, let's zoom in on the machines themselves. In the next section, we're going to open up the hood and look at how computers and operating systems actually work. Let's recap module one. You now know that IT is every system that keeps a business running.
That goes from the app customers use to the person who resets your password. You've seen how one food order sets off a whole chain of those systems. And you know companies use them in two ways, to run the business from the inside and to serve customers. When those systems go down, the business feels it right away. Welcome to module two. Let's look at the machine your code runs on. We'll begin with the simple loop every program follows and the three physical parts your app depends on. After that comes the operating system and the rules it sets for your code. We finish with the screen full of plain text that developers work in and why many of them prefer it to a mouse.
By the end of this module, you'll understand why an app can run out of memory. You'll also know why servers are often run by typing commands. Let's begin. Let's clear this up right away. If you get a computer science degree, you'll spend months calculating binary code. But honestly, I never calculate binary on the job. Let's look at computers the way a working developer does. At its core, a computer is a digital machine. That just means it stores everything as tiny electrical switches that are either on or off, ones and zeros. Every photo, song, and piece of software is just millions of these switches.
But you don't need to read the ones and zeros. You just need to know a computer is a fast calculator that does exactly three things, input, process, output. Think about logging into Instagram or Netflix. You type your password and click a button. That's the input. The system checks if your password is correct. That's the process. It loads your feed. That's the output. Every piece of software you will ever work on is just doing that loop. Your job as a developer is to write the process part. The computer doesn't try to fix your code. It just follows instructions like a very obedient robot. If your code is broken, the machine will execute that broken code perfectly.
That's exactly why debugging is such a massive part of the job, and we'll get into that later. But first, let's look at the physical hardware that actually runs your code. Every app you've ever used depends on just three physical parts. If even one of them fails, your app dies. Those parts are storage, RAM, and the CPU. Storage is your hard drive. It's where data lives permanently. It holds a massive amount of data, but pulling that data is slow. RAM is your active memory. When someone opens your app, the system pulls it from slow storage into fast RAM so it runs smoothly. But RAM is strictly limited.
If your code loads too much data at once, RAM fills up and the app freezes. The CPU is the engine. It executes your logic and does the actual math. You need to care about this because when your company hosts an app in the cloud, they pay for these resources based on usage. If you write bloated code, your app chews through RAM and CPU. That drives up your AWS bill, or worse, your app crashes in production because the server ran out of memory. Storage is where data is saved. RAM is where data works, and the CPU does the heavy lifting. But hardware is completely useless on its own. It needs a manager, which brings us to the operating system.
You might think your code runs directly on the computer's hardware, but in reality, your code isn't even allowed to touch it. Hardware only understands electricity. It has no idea what a database or a web browser is. We use an operating system, like Windows, Mac, or Linux, as a middleman. In tech, we call this abstraction. When your backend reads from a database or sends a response over the network, it's not doing it directly. Your code is asking the operating system to do it for you. To keep things safe, the operating system is divided into two strict zones. First, there is kernel mode. This is the core engine.
It has absolute power over the hardware. Second, there is user mode. This is where your code runs. User mode is basically a restricted bubble. Your app cannot directly touch the hardware or mess with other programs. If your code tries to access memory it doesn't own, the kernel immediately shuts it down. This is exactly why one buggy app can't take down the whole machine, and it's why you'll see errors like segmentation fault or out of memory on the job. That's the kernel stepping in and stopping a program before it damages anything else. Here's the thing. You probably use a Mac or Windows right now, but the servers that run the internet overwhelmingly run Linux.
If you look at the web servers where the operating system can be identified, more than nine out of 10 run a Unix-style system, and most of those are Linux. You don't need to be an expert in it today, but you need to understand that the environment where you write your code is usually different from the Linux server where your code actually lives. And when you deploy your code to that Linux server, you won't have a mouse to click around with. Let's talk about the command line. Here is something most beginners don't realize. When developers deploy code to a server thousands of miles away, they aren't clicking buttons on a screen.
You've spent your entire life using a mouse, clicking icons, dragging folders. It's comfortable. Early on, most people rely on the mouse. Over time, you'll notice developers lean on the keyboard instead because for repetitive or technical tasks, it's usually a lot faster. What you are used to is called a GUI, a graphical user interface. But when you get on a dev team, you'll see developers staring at black screens with white text. That is the CLI, the command line interface. It's not hacking. It does the exact same thing your mouse does. Typing a simple text command in the CLI is exactly the same as right-clicking and hitting new folder with your mouse.
Developers do this for two reasons, speed and automation. You cannot easily automate 100 mouse clicks, but you can write a one-line script to do it instantly in the command line. More importantly, when you deploy your back-end code to a Linux server in the cloud, there is often no screen and no mouse waiting for you. It's a remote machine that expects text commands. Even on teams where deployments run through an automated pipeline, that pipeline is usually built and maintained using the CLI. So sooner or later, you'll need it. You don't need to memorize a dictionary of commands today. Just know that as you step into this industry, you'll notice developers rely heavily on the keyboard because it's much faster.
Now that you know the hardware and the OS, it's time to look at the actual software. In the next section, we are going to break down exactly what happens when you type a website into your browser. I'll see you there. Let's recap module two. You saw that programs take input, process it, and give output, and that your job is to write the process part. That code depends on three physical parts. Storage keeps data, RAM holds what's being worked on, and the CPU does the work. Use too much memory or CPU and your cloud bill goes up or your app crashes. The operating system sits between your code and the hardware.
That's why one buggy app usually can't take down the whole machine. And since most web servers run Linux, often with no screen or mouse, developers get comfortable with the command line. Welcome to module three. Let's see what happens when someone uses a website. We'll take one page load apart piece by piece. Along the way, you'll meet the front end, the back end, APIs, and the database, and you'll see what each one is responsible for. You'll also learn to read status codes, a small skill that helps you find problems much faster. The last part compares websites and mobile apps. By the end of this module, you'll be able to look at a failed request and say which part to check first.
Let's start in the browser. You open your browser, type a website address, and within a second, the page appears. It feels simple, but behind that one click, your computer is talking to other computers, sending requests, receiving data, and putting everything together into a page you can use. Let's break down what actually happens. First, you open a browser like Chrome or Safari. You type a website address, such as example.com, and press enter. Your browser needs to find the server hosting that website. This is where DNS comes in. DNS stands for Domain Name System. It translates a domain name, like example.com, into an IP address that computers can use to locate the destination.
You don't need to memorize the entire DNS process right now. Just remember this. Humans use names, computers use addresses. Once the browser knows where to connect, it sends a request to the server. This is called an HTTP request. For example, your browser might ask, give me the homepage. The server receives that request and decides what to do. Maybe it returns an HTML page. Maybe it needs to fetch some data. Maybe it needs to check whether you're logged in. The server processes the request and sends a response back. That response might contain HTML, CSS, JavaScript, images, or data. Your browser receives those files and uses them to display the website.
By the way, you can actually watch all of this happen. Every browser has a developer tools panel, and the network tab shows every single request your page makes. You'll use it in the assignment for this section. And that's the basic idea. You request something, a server processes it, you receive a response. Now, here's something important. The website you see is not necessarily running entirely on your laptop. The browser is responsible for displaying and running the front end. The back end may be running on a completely different machine, possibly in the cloud. That's why developers need to understand how these pieces communicate.
Because when a user says the website isn't working, the problem could be in the browser, the network, the back end, or somewhere else. And that brings us to the next question. What exactly is the front end and what does the back end do? When you use an application, there are usually two major parts you need to understand, the front end and the back end. And if you're entering software development, you'll hear these two words constantly. Let's use a simple example. You open an online shopping website. You can see products, search for items, add something to your cart, and place an order. Everything you see and interact with in the browser is part of the front end.
The front end is the user-facing part of the application. It handles things like what appears on the screen, what happens when you click a button, how a page responds to your actions, and how data is displayed. Common front-end technologies include HTML, CSS, and JavaScript. Frameworks like React, Angular, and Vue are also used to build front-end applications. But here's the important part. The front end usually doesn't own all the data or business logic. For example, when you open a product page, the front end needs product information. Where does that information come from? That's where the back end comes in.
The back end runs on the server side. It handles things like processing requests, applying business rules, accessing data, and communicating with other systems. Let's say you click Add to Cart. The front end knows you clicked the button, but the back end may need to check the product, verify availability, calculate the price, and save the cart. The front end displays the result. The back end handles the work behind the scenes. Now, don't think of front end and back end as two completely separate applications that never interact. They work together. The front end is responsible for the user experience.
The back end is responsible for server-side processing and data access, and they communicate through APIs, which we'll cover next. One more thing. A front-end developer doesn't necessarily need to know every back-end technology, and a back-end developer doesn't necessarily need to build the front end. But both developers need to understand how their work connects. Because if the front end sends the wrong request, the back end may reject it. And if the back end returns the wrong data, the front end may display something incorrectly. That's why understanding the complete application is useful, even if you specialize in one area.
Now let's look at the piece that connects these two sides, the API. API is one of those words you'll hear everywhere in IT. Front-end developers talk about APIs, back-end developers build APIs. QA engineers test APIs, and cloud applications communicate with APIs all the time. So what is an API? Let's keep it simple. An API, or application programming interface, is a defined way for software to communicate with other software. Think about a restaurant. You look at the menu and decide what you want. You tell the waiter your order. The waiter takes it to the kitchen. The kitchen prepares the food, and the waiter brings it back.
You don't need to walk into the kitchen and figure out how everything works. You just use the interface provided to you. An API works in a similar way. Let's say your front end needs to display a list of products. It sends a request to the back end through an API. The back end processes that request, gets the required data, and sends a response. The front end receives the response and displays the products. For example, an API might have an endpoint that simply means give me the products. The response would come back as structured data, something like a list of products, each one with an ID, a name, and a price.
The front end can use that data to display the products on the screen. You don't need to memorize the technical format right now. We'll keep the deeper details for another course. But understand this. An API is a contract between systems. It defines how one piece of software can request something from another piece of software. And it's not limited to front end and back end. A payment system can communicate with a shopping application through an API. A weather application can request weather data from a weather service. A mobile app can communicate with the same back end used by a website. That's why APIs are such a big part of modern software.
Now, every one of those API calls comes back with a little status code. And once you can read that code, you can tell where a problem is before anyone else on the team. Let's look at that next. Here's a skill that takes about 3 minutes to learn and will make you look like you've been doing this for years. Every time the front end talks to the back end, it sends a request and gets a response. And every response carries a three-digit number called a status code. That number is the back end's one-word answer to the question, how did that go? You only need to know a handful. Anything starting with two means fine.
200 is the classic. You asked for the products, here are the products. Anything starting with three means look somewhere else. A 301 or a 302 is a redirect. The page moved. Anything starting with four means you, the caller, got something wrong. 400 means the request itself was malformed. 401 means you're not logged in. 403 means you're logged in but not allowed. And 404, the famous one, means the thing you asked for doesn't exist. Anything starting with five means the back end got something wrong. 500 is a generic crash on the server. 502 or 503 usually mean the server is down or overloaded. So look at this one.
The front end sent get/api/products. The back end answered 200 and the body is a small piece of structured text called JSON. An ID, a name, a price. That's the whole conversation. The front end takes that JSON and turns it into a product card on the screen. Now here's why this matters for you. Remember the question from the first lecture? The website isn't working. Where's the problem? If the request never left the browser, it's the front end. If it came back with a four, the front end probably sent the wrong thing. If it came back with a five, the back end broke. If it came back 200 and the screen is still wrong, the front end is displaying the data incorrectly.
Four scenarios, one number tells you which one you're in before you touch a single line of code. Now the back end needs somewhere to keep the data it's sending back. That's the database. Let's say you create account on a website. You enter your name, email, and password. You close the browser, come back tomorrow, and your account is still there. Where did that information go? It was stored somewhere. That's the job of a database. A database is a system used to store and manage data so applications can retrieve and work with it. In a typical application, the flow looks like this. The front end collects the user's input, the back end processes the request, and the database stores or retrieves the information.
Let's take a simple example. You log into an application. The front end sends your login details to the back end. The back end checks the stored account information and verifies the credentials. If the login is successful, the back end sends a response and the front end displays your dashboard. The database is where the application keeps information such as users, products, orders, or other business data. Now, there are different types of databases. Relational databases, such as MySQL, PostgreSQL, and SQL Server, store structured data in tables. NoSQL databases, such as MongoDB, use different data models and are often used for applications with particular data and scaling requirements.
You don't need to learn database design in this course, but you should understand the difference between the application and the data it uses. Your back end code is not necessarily the permanent storage. The database is a separate system responsible for managing data. And this distinction matters in real jobs. If a user says their order disappeared, the problem might be in the front end, the back end, or the database. If an application is slow, the database could also be part of the problem. That's why developers need to understand how data moves through an application. Now, one last question.
Does a mobile app work completely differently from a website? Not necessarily. You use a website on your laptop. You open the same service on your phone and the experience looks a little different. The buttons may be arranged differently, the layout may be different, the app may use mobile specific features. But here's the important part. Both applications can communicate with the same backend. For example, imagine you're using a shopping application. You add an item to your cart on your laptop. Then you open the mobile app and the same item is still in your cart. How does that happen? Because both clients can use the same backend and access the same underlying account data.
The website and the mobile app are different clients. They may have different front end technologies. A website might use React. A mobile application might use Swift, Kotlin, or a cross-platform framework like Flutter or .NET MAUI. But they can still communicate with the same backend through APIs. This is a useful concept to understand before entering IT. You might work on a front end team, a back end team, or a mobile team. Even if your technology is different, the application architecture can be connected. And that's the bigger picture. The front end displays the experience. The back end processes the requests.
The API connects systems. The database stores the data. Once you understand these four pieces, a lot of software development starts making more sense. In the next section, we'll move into programming basics and look at how developers actually write the logic behind these applications. Let's recap module three. You followed one request from start to finish. DNS turned a name into an address. The browser asked a server for a page and a response came back. You saw how the work splits between the two sides of an application. An API is the agreed way for them to talk. Status codes gave you a quick way to find a problem.
A four usually points at the caller. A five points at the back end and a 200 with a wrong screen often points at the front end. And since the data lives in a separate database, your cart can follow you from your laptop to your phone. Welcome to module four. Now let's look at the code that makes an application work. You don't need any coding experience for this. We'll go through what programming really is and the few ideas you'll find in nearly every language. You'll see how developers avoid writing the same logic twice and why errors are a normal part of the work. We finish with the code your project uses that somebody else wrote.
By the end of this module, you'll know the ideas behind most code. You'll also know why a real project is full of code your team didn't write. Let's start with what programming actually means. Programming is basically giving a computer a set of instructions to follow. When you're writing code, you're not really talking to the computer in some magical way. You're breaking a problem down into steps that a machine can execute. For example, let's say you are building a shopping application and the user clicks buy now. Something has to happen behind that button. Check whether the product exists, check whether it's in stock, calculate the price, create the order, save the order, return a response.
That's programming. The language might be Python, Java, C Sharp, JavaScript, or something else. The syntax changes, but the underlying idea stays the same. Take a problem, break it into logical steps, and tell the computer exactly what to do. And this is one of the biggest mindset shifts for beginners. Programming isn't primarily about memorizing syntax. It's about learning how to turn a problem into a sequence of instructions. Before you work on real applications, there are a few programming concepts you'll see everywhere. The first is a variable. A variable is simply a name pointing to some data.
You might have a username, an order total, a product ID, or whether a user is logged in. Variables let you store information and use it later. You can also update their values as your program runs. For example, when a customer adds another item to their cart, you can update the variable holding the total number of items. Then you have conditions. This is where your program makes decisions. For example, if the user is logged in, show their dashboard. Otherwise, show the login page. You can also combine conditions to handle more complex situations. For example, you might check whether a user is logged in and whether they have permission to access a particular page.
Conditions help your application respond differently depending on the data or situation it encounters. Then you have loops. A loop is useful when you need to repeat something. Let's say you get a hundred products from a database and need to process every one of them. You don't write the same code a hundred times. You write the logic once and repeat it. Loops can also stop when a particular condition is met, which is useful when you don't know exactly how many repetitions you'll need. For example, you could use a loop to calculate the total price of every product in a customer's shopping cart. These three ideas show up everywhere.
Store data, make decisions, repeat work. Whether you're working in Python, Java, C Sharp, JavaScript, or another language, you'll keep coming back to these concepts. One of the first things that separates beginner code from more practical code is understanding functions. Let's say your application needs to calculate the total price of an order. You could write that logic directly inside your checkout code. But what happens when another part of the application needs the same calculation? You'd end up copying the code. That's where functions help. You put a specific piece of logic inside a reusable function and call it whenever you need it.
For example, you might write a small function called calculate total, which takes in a price and a quantity and simply returns the price multiplied by the quantity. Now you don't care how many times you need that calculation. You can call the function whenever you need it. You can also update the calculation in one place without changing every part of your application. For example, if you later need to include a discount, you can update the function to handle that requirement. Every part of the application that calls this function can then use the updated logic. In real projects, functions get combined into larger components, services, classes, modules, and applications.
So when developers talk about writing reusable code, this is what they're getting at. Functions also make code easier to test because you can check a specific piece of logic independently. They help break large problems into smaller pieces that are easier to understand and maintain. Don't write the same logic again and again when you can isolate it and reuse it. Here's something beginners usually discover very quickly. Your code will break. And that's completely normal. You might have a syntax error because you wrote something incorrectly. You might have a runtime error because something went wrong while the application was running.
Or the code might run perfectly but still produce the wrong result. That's a logic error. And that last one is especially important. A program can be completely valid from the computer's perspective and still be wrong from the user's perspective. That's why developers spend a surprising amount of time debugging. We'll walk through how that actually looks, error message and all, in the next section. For now, the mindset is what matters. You fix the actual cause. You don't randomly change code until the error disappears. Sometimes the error message points directly to the problem. Other times you need to trace the execution and understand what the code is actually doing.
That 's why reading error messages carefully is such an important skill. They often provide clues about where things went wrong and what to investigate next. You are not trying to write perfect code that never breaks. You're learning how to understand and fix problems when it does. One final concept beginners should understand is that developers rarely build everything from scratch. Let's say your application needs to send an email. You could spend weeks building an entire email system yourself, or you could use an existing library or service that already solves the problem. That's why developers use libraries and frameworks.
A library gives you reusable functionality. A framework gives you a larger structure for building applications. And these projects often depend on many other packages. Those are called dependencies. For example, a library might handle email formatting, while another package handles communication with an email service. Using these existing tools saves time and lets you focus on the specific requirements of your application. Of course, you still need to understand what these dependencies do and whether they fit your project's requirements. This is why you'll eventually see certain files in almost every project.
JavaScript projects have a file called package.json. Python projects have a file called requirements.txt. Java projects have a file called pom.xml. And .NET projects have a project file ending in .csproj. These files help define what your application depends on. They also help other developers install the required packages and get the project running in their own environments. So when you join a real project, you're usually not starting with an empty folder. You're joining an existing codebase with existing frameworks, libraries, dependencies, and conventions. And that's much closer to what real software development looks like.
Let's recap module four. Programming means breaking a problem into steps a computer can follow. The syntax changes from one language to another, but that idea stays the same. Variables, conditions, and loops let a program store data, make decisions, and repeat work. Functions let you write some logic once and use it wherever you need it. Errors come in three kinds, and the logic error is the hard one because the code runs and the result is still wrong. And libraries and frameworks mean you rarely build everything yourself. In module five, we look at how a team works on code together. Welcome to module five.
This is where the real job begins. On a real team, you rarely decide on your own what to build. Work comes to you in a certain way. It moves through a set of steps and other people are involved at each one. You'll join a codebase you didn't write and you'll get a ticket that says what's needed. Someone will ask how long it's going to take. You'll make your change with Git and you'll see the different environments code passes through. When you're done, you'll hand your work to a teammate in a pull request. By the end of this module, you'll be able to take a ticket and follow it through your team's steps.
Let's start with the code that's already there. One of the biggest surprises for new developers is that most of the time you're not building something from an empty folder. You join a company, open your laptop, clone a repository, and discover that hundreds of files are already there. There are APIs, database queries, configuration files, tests, logging, authentication, deployment scripts, and code written by people who may have left the company years ago. And then your manager gives you a ticket, something like add a new field to the customer API. That sounds simple, but before changing anything, you need to figure out where that API is implemented, where the data comes from, which database table contains the field, whether another service uses the same model, whether tests already exist, and whether adding the field could break something else.
You might also need to understand how the application is configured and how changes move from development into production. Sometimes the hardest part isn't making the change itself, it's discovering all the places that change might affect. This is why being a developer is not just about writing code. A huge part of the job is understanding code that already exists. Over time, you'll learn to follow the flow of data, identify important files, and recognize how different parts of an application connect. Your first skill on a real project isn't typing faster, it's getting comfortable moving through code you didn't write, a skill worth its own closer look later in this course.
In many companies, your work starts with a ticket. You might hear terms like Jira, Azure DevOps, Linear, or GitHub issues. The tool changes, but the idea is similar. Someone creates a piece of work that needs to be done. For example, a ticket might say, add email validation to customer registration. The description explains that users should not be able to register with an invalid email address, and the acceptance criteria might say, the email format needs to be validated, an error message should show up when it's wrong, unit tests need to be added, and existing valid registrations must continue working.
The important part is that a ticket usually describes the problem and the expected outcome, not every line of code you need to write. It's your job to understand the requirement and figure out how to implement it. Sometimes the ticket might leave important details unclear. You may need to ask questions, discuss edge cases, or clarify what should happen when something goes wrong. You'll also see different types of tickets. A bug means something isn't working correctly. A task is a piece of implementation work. A story is a larger piece of functionality from the user's perspective, and an epic is a larger body of work made up of multiple smaller tickets.
Once you understand this, a ticket stops looking like an instruction from your manager and starts looking like the starting point for an engineering problem. You also need to think about how your change fits into the existing application and whether it introduces any risks. And once you understand the problem, someone's going to ask you the next question. How long do you think this will take? Once a ticket exists, someone usually has to answer a question that feels harder than it should be. How long will this take? Many teams don't answer that in hours. They use story points, a rough relative measure of effort and complexity rather than a literal time estimate.
A small, well-understood change might be a one or a two. Something that touches several parts of the system or has a lot of unknowns might be a five or an eight. The exact scale differs by team, and that's fine. The number itself matters less than the conversation that produces it. Here's the part beginners aren't warned about. Your estimates will sometimes be wrong, often in your first year, and that's expected, not a sign you're bad at the job. A ticket that looked like a two-day change can turn into a week once you discover an edge case nobody mentioned or a piece of the system that behaves differently than documented.
What actually matters isn't estimating perfectly. It's noticing early and saying something. If you're a day into a two-day ticket and you can already tell it's going to take four, that's the moment to flag it and stand up on the ticket wherever your team tracks this, not on the final day when it's already late. Something like, this is turning out bigger than expected because of X. I think it's closer to four days now. That single sentence, said early, is the difference between a manageable surprise and a stressful one. So don't treat an estimate as a promise carved in stone. Treat it as your best guess with the information you had at the time and treat updating it honestly as part of the job, not a failure to admit.
Once your ticket is estimated and picked up, the next thing you'll actually spend most of your day using is Git. If you're working in software development, Git is going to become part of your everyday workflow. You pull the latest code, you create a branch, you make your changes, you commit them, you push the branch. Then you create a pull request. Someone reviews it, and once it's approved, it gets merged. The important thing to understand is that Git isn't just a place where code is stored. It's how teams safely work on the same codebase. Two developers can work on different features without constantly overwriting each other's work.
Your branch gives you an isolated place to make changes, and the pull request gives the team a chance to review those changes before they become part of the main codebase. For example, imagine you're adding a new payment feature while another developer is fixing a login issue. You can both work on separate branches and commit your changes independently. Once your work is ready, Git helps bring those changes together. Sometimes you'll encounter merge conflicts when different changes affect the same part of a file. You'll need to understand what changed and decide how to combine the work correctly.
Git also keeps a history of your changes so you can understand what happened and return to earlier versions when necessary. You'll eventually encounter terms like commit, branch, merge, pull request, rebase, conflict, checkout, and clone. You don't need to master all of Git before your first job, but you absolutely need to understand why Git exists and how it fits into the development workflow. Here's another concept that becomes very real when you join a company. Your code usually doesn't go directly from your laptop to the real users. There are different environments. Development is where developers build and test their changes.
Some teams also have an int environment, short for integration, which is where your changes are combined with everyone else's changes for the first time, just to make sure nothing conflicts. Test or Q A is where the application is validated before release. Many companies also have a staging environment, which is set up to look and behave almost exactly like production so the team can do one final check before anything goes live. And production is the real environment used by actual customers. Your code typically moves through several of these stages in order from your machine to dev, maybe to int, to test, to staging, and finally to prod.
Not every company uses all of these environments and some combine a few of them, but the idea tends to be the same. Catch problems earlier in a safer environment before they ever reach a real customer. And this distinction matters. You don't want to test a database migration by experimenting directly on the production database. You don't want unfinished features appearing in front of customers, and you don't want a developer casually changing production configuration because they were trying to fix something. Later in the course, we'll talk about how C I C D helps move changes between these environments safely.
For now, remember one thing. Your laptop is not production. You finish your ticket, you open a pull request, and now a teammate who wasn't in your head while you were writing this has to figure out what you changed and why, usually in the middle of their own busy day. A weak pull request just says fixed the bug and links the ticket. A good one saves the reviewer real time. It says what changed, why you approached it that way, and how to actually test it. A specific input, a specific screen, a specific expected result. Think of it like handing off a task to a co-worker who's about to go on vacation.
You wouldn't just say I did the thing, you'd say what you touched, what you didn't touch, and what to double check. This matters for your commit messages too. Fixed stuff tells a future developer nothing. Fix null pointer when discount is applied to an empty cart tells them exactly what problem existed and when it happened. The same habit applies inside your code. A comment shouldn't restate what the next line obviously does. It should explain the part the code can't show on its own, why this particular edge case needed a special check, or why you didn't use the simpler approach. Good documentation also helps when someone needs to investigate a problem later.
They can understand the original decision without having to track down the person who made it. None of this is about writing more. It's about writing exactly enough that the next person, maybe you 6 months from now, doesn't have to guess. So once your pull request is actually open, what happens next? That's where code review comes in. Code review is simple to describe. A teammate reads your change before it joins the main codebase. Sometimes they approve it right away. Often they'll leave a few comments. They might ask a question, point out a case you missed, or suggest a simpler way to do something.
You make the changes and push them to the same branch, and the pull request picks them up. Once your teammate approves, your branch gets merged. Those comments can feel personal the first few times. They're about the code, and senior developers get them too. They also teach you how your team likes things done. So let's recap module 5 and how far your ticket came. You found your way around code you didn't write. You understood what was being asked, gave an estimate, and worked on your own branch. Along the way, you saw the environment's code passes through on its way to customers. Then you wrote a pull request that someone could follow, and it got reviewed and merged.
Up to this point, your change has only moved inside the team. In module 6, it goes the rest of the way, out to the using the app. Welcome to module six. Now let's see what happens between your laptop and production. This one is longer because a lot happens at this stage. see how code becomes something that can run, a container is, how a pipeline moves it all along. also see where settings and passwords belong since they stay out of the code. comes up twice. first time, it's the habits every company assumes you have. The second time, it's how you handle people's data and how you build for people who use software differently.
The rest is about going live safely. That covers deployments and going back to an older version. It also covers turning features on without a new release and changing an API without breaking the apps that use it. By the end of this module, you'll know what people mean by a failed build, a red pipeline, or a rollback. Let's start. You finished your ticket. The code works on your machine, but that doesn't mean the feature is ready for customers. Before your change reaches production, several things usually need to happen. Your code needs to be built, tests need to run, the application may need to be packaged, security or quality checks might run.
Then the application needs to be deployed to an environment. A simplified version of that journey looks like this. You write the code, you commit it, it gets built, it gets tested, it gets packaged, it gets deployed, and finally, it gets verified. The exact process depends on the company and technology stack. A small application might have a very simple pipeline. A large enterprise application might have dozens of automated checks before anything reaches production. For example, if a test fails after your latest change, the pipeline can stop the deployment before the problem reaches customers.
Teams also use different environments, such as development, testing, staging, and production. Each environment serves a different purpose, helping teams validate changes before exposing them to real users. Sometimes, a deployment succeeds technically, but the application still behaves incorrectly. That's why teams also monitor logs, metrics, and application health after releasing a change. And if something goes wrong, teams need a way to roll back the release or quickly deploy a fix. This is one reason teams automate these steps instead of relying on someone to remember every check manually. You'll often hear these processes described as continuous integration and continuous delivery or CICD.
The important thing to understand is that writing the code is only one part of delivering software. You will hear developers talk about building an application. What does that actually mean? It depends on the language. Some languages need source code to be compiled into another form before it can run. Others may be interpreted or packaged differently. But the general idea is the same. You start with your source code and produce something that can actually be executed or deployed. For example, a project might contain your source code, its dependencies, some configuration, and a set of tests. All of that goes through a build process, and out the other end comes an application package.
That package could be a container image, a compiled application, a deployment artifact, or another format depending on the technology. And this is why developers don't simply copy random source files onto a production server. There is usually a repeatable process that turns source code into something deployable. A build process can also catch problems early, such as compilation errors, missing dependencies, or incorrect configuration. In a team environment, the goal is to make sure the same source code produces a consistent, predictable result every time the application is built. Once the build is complete, the resulting artifact can move through testing and deployment without developers having to manually assemble the application each time.
And these days, more often than not, that something is a container. Let's talk about what that actually is. You will hear the word container in your first week, probably your first day. So, let's make sure it doesn't scare you. Here's the problem containers solve. The application works on your laptop. Then it goes to the test server and breaks. Different operating system version, different version of a library, a missing configuration file, and the sentence every developer has said at least once, but it works on my machine. A container fixes that by packaging the application together with everything it needs to run.
The code, the runtime, the libraries, the settings, all of it in one sealed box. That box runs the same way on your laptop, on the test server, and in the cloud because it carries its own environment with it. A widely used tool for this is Docker. And the recipe for a container is a small text file called a Docker file. You'll see it at the root of many repositories. It just says, start from this base, copy my code in, install the dependencies, and here's the command to run. Two words you'll hear together. An image is the packaged box sitting on a shelf. A container is that image actually running.
Same relationship as a recipe and a meal. So, when the build pipeline from the last lecture finishes, what often comes out the other end is a container image. That image gets pushed to a registry, which is just a storage shelf for images. And when it's time to deploy, the server pulls the image down and runs it. You don't need to write Docker files on day one. But when someone says the image didn't build or the container keeps restarting, you now know exactly what they're talking about. Now let's look at the machinery that builds and ships all of this automatically. CI/CD. Now we get to one of the most important concepts in modern software development.
CI/CD. CI usually means continuous integration. The idea is that developers integrate their changes into the shared code base regularly, while automated checks help catch problems early. CD can refer to continuous delivery or continuous deployment depending on the setup. The basic idea is that software can move through the delivery process in a controlled and repeatable way. For example, a developer pushes their code and the CI/CD pipeline picks it up automatically. It builds the code, runs the tests, runs quality checks, and deploys it. These pipelines are usually triggered by events such as pushing code, opening a pull request, or merging changes into a particular branch.
Instead of a developer manually logging into a server every time and copying files around, the pipeline can perform these steps automatically. This is one of the major differences between a small personal project and a mature engineering environment. Continuous delivery means the application is kept ready for release, often with a manual approval before production deployment. Continuous deployment takes this further by automatically releasing changes that pass all required checks. The more software you have, the more valuable automation becomes. And when one of those steps turns red, that's not a disaster.
That's the pipeline doing its job. It caught the problem before a customer did. Teams can also configure notifications so developers know which step failed and can investigate the problem quickly. You don't want your production process to depend on someone remembering 15 manual steps. You want the process itself to be repeatable. Here's another thing beginners often discover when they move from small projects to real applications. Your code is usually the same across environments, but the configuration is not. For example, your application might need a database URL, an API endpoint, a storage account, some application settings, feature flags, and credentials.
You don't want your production database URL hardcoded inside your source code. Instead, applications usually get this information through configuration or environment specific settings, often stored as environment variables with names like database URL, API URL, or storage account. The actual values can change between development, testing, and production. For example, your development environment might connect to a local database, while production connects to a managed database hosted in the cloud. The application code can stay the same while the configuration determines which database it uses.
This is also why secrets need special handling. Passwords, API keys, and credentials should not simply be committed to Git and left sitting inside the repository. Even if you remove a secret in a later commit, it may still exist in the repository's history. That's why you should rotate exposed credentials immediately, rather than assuming deleting the file has solved the problem. In real projects, you'll often work with secret managers, environment variables, or other secure configuration systems. One important distinction is that environment variables are a way to provide configuration, not automatically a secure place to store secrets.
Production applications often use dedicated secret management systems to control access and manage credentials safely. The key idea is simple. Code and environment specific configuration should be treated separately. And since we just mentioned secrets, let's spend a few minutes on the security habits every developer is expected to have. Not the security team, you. Nobody expects a junior developer to be a security expert, but there are five habits that every company assumes you already have. If you don't, you find out the hard way. First, secrets never go into Git. Passwords, API keys, tokens, connection strings, once a secret is committed, it's in the history forever, even if you delete it in the next commit.
And on public repositories, automated bots are commonly scanning for exactly this kind of leaked key, often catching them quickly. This is why production projects typically keep secrets in environment variables or a secret manager, and why there's a file called .gitignore that tells Git which files to never touch. If you accidentally commit a secret, tell your team immediately and rotate or revoke that credential. Removing it from the latest version of the code is not enough to make it safe. Second, never paste production data or secrets into an AI tool or a public chat or a ticket. It's incredibly tempting when you're debugging.
Just paste the whole log with the customer's email in it into the assistant. Don't. Strip it first. Leaks like this have caused real, costly incidents at real companies. Even when a tool is approved by your company, understand its data handling rules before sharing sensitive information. Use sanitized examples whenever possible. Third, never trust input from the outside. Remember our registration form? A user can type anything into that email field, anything, including things designed to break your database. The backend validates every input as if the user is actively trying to hurt you, not because most are, because one will.
And validation alone isn't enough for every threat. For example, database queries should use parameterized statements instead of building SQL by joining user input directly into a query. Fourth, HTTPS, always. That's the padlock in the browser. It means the data between the user and the server is encrypted. Every login form, every API, every environment including test. You should also avoid disabling certificate validation just to make a connection work. That check helps verify that you're communicating with the intended server. Fifth, least privilege. You get access to what you need for your job and nothing more.
So when you don't have right access to the production database on day one, that's not the company being difficult. That's the company protecting you. A junior developer with full production access is one typo away from a very bad day. The same principle applies to application permissions. A service should only have the access it needs and credentials should never be shared casually between people or applications. None of this is complicated, but you'll notice that experienced developers do all five without thinking. Start now and by your first job, it'll be automatic for you too. All right, the code is built, packaged, configured, and secured.
Now it needs to actually reach the environment. Let's look at what happens during a deployment. Let's say everything passed. The application has been built, tests passed, the deployment pipeline is ray. Now the new version needs to reach the environment. That might mean deploying a container, updating a cloud service, publishing an application package, running infrastructure changes, or updating a server. And deployment isn't always just upload new code and hope for the best. A mature deployment process might include a health check right after deploying, then some smoke tests, then ongoing monitoring before it's considered a real success.
Some teams also use gradual rollouts, releasing the new version to a small percentage of users before making it available to everyone. This helps limit the impact if something goes wrong. And sometimes the deployment fails. Maybe the application starts but can't connect to the database. Maybe a configuration value is missing. Maybe a new change causes an unexpected error. Sometimes the deployment itself succeeds but users start experiencing slower response times or errors that weren't caught during testing. That's why teams watch application metrics and logs closely after a release. For critical applications, teams may also use blue-green deployments where two environments are maintained so traffic can switch between the old and new versions when needed.
Another approach is a canary deployment where the new version is introduced gradually while the team checks its behavior before expanding the rollout. That's why deployment and monitoring are connected. You don't just ask, did the deployment finish? You also ask, is the application actually healthy after the deployment? Because ultimately, a successful deployment isn't just about getting new code into production. It's about making sure the application continues working reliably for the people using it. Now let's talk about something every developer eventually learns the hard way. A deployment can pass every automated test and still cause a problem in production.
Maybe a strange edge case wasn't covered. Maybe the production data is different from your test data. Maybe an external service behaves differently. When that happens, one option is a rollback. That means moving the application back to a previous known good version. Say you released version 1.5 and it caused a production issue. A rollback simply puts version 1.4 back in place while the team figures out what went wrong. For example, imagine a new release causes the checkout page to fail for some customers. Instead of making everyone wait for a fix, the team can roll back to the previous version and restore the checkout experience.
The goal isn't to pretend mistakes don't happen. The goal is to make failures recoverable. Of course, rolling back application code doesn't automatically reverse database changes. If a release changes the database structure or modifies existing data, the team needs to consider whether those changes are compatible with the previous version. That's a major principle in modern engineering. You don't design systems assuming nothing will ever go wrong. You design the process so that when something does go wrong, the team can detect it, respond to it, and recover safely. This is also why teams plan their recovery strategy before releasing risky changes rather than figuring everything out during an incident.
And recovering safely starts with knowing exactly what data you're responsible for in the first place. A support engineer pastes a customer's full account details, name, email, and order history into a chat tool to ask for help debugging. Nothing malicious happened, but that data just left a system built to protect it and landed somewhere it was never supposed to go. This is what people mean by PII, personally identifiable information. It's anything that can identify a specific person, a name, an email, a phone number. Sometimes it's even a combination of details that aren't identifying on their own, but become identifying together.
Handling it carelessly isn't just a security slip. In many places, it's a legal one, too, under rules like GDPR in Europe. Those rules require companies to know where personal data lives, who can see it, and how to delete it if someone asks. The habit that matters most day-to-day is minimizing exposure. When you're debugging, strip personal details out of logs and examples before you share them, the same way you'd strip a password out of a screenshot. When you're building a feature, ask whether you actually need to store a piece of personal data at all or whether a reference to it elsewhere would do the job.
Data you never collected can never leak. Accessibility is a related habit that's easy to treat as optional and isn't. A meaningful share of users navigate software with a screen reader or without a mouse or with reduced vision. Small things carry a lot of weight here. Don't convey meaning through color alone. Give images alternative text that describes what they show. Make sure interface elements can be reached and activated using only a keyboard. None of this requires becoming an accessibility specialist. It requires checking before you ship a screen whether someone using only a keyboard could actually get through it.
Both of these habits share the same shape. They're invisible when you get them right, and they only become visible, often publicly and expensively, when you get them wrong. That's exactly why they're easy to skip under a deadline and exactly why the teams that build them in as habits rather than afterthoughts tend to avoid the worst version of that story. A team finishes a new checkout flow and wants to ship it carefully, not all at once to every user. So they wrap the new flow in a feature flag and deploy it to production with the flag switched off. The code is live on every server. Nobody sees it yet.
That split is the whole idea. Deploying code means moving it to production. Releasing a feature means users can actually reach it. Most of the time those two things happen together. You deploy and users see the change immediately. A feature flag breaks that link on purpose. A feature flag is a setting, often just true or false, that the code checks before deciding which path to run. Turn it off and users get the old behavior. Turn it on and they get the new one. The team can turn it on for themselves first, then a small percentage of real users, then everyone, watching for problems at each step.
This changes how risk gets managed. If the new checkout flow breaks something, the fix isn't a rollback and a redeploy. It's flipping the flag back off, which usually takes seconds. The bad code is still sitting in production, but nobody is running it anymore. Flags show up in smaller, everyday forms, too. A flag that hides an unfinished feature from everyone except the team building it. A flag that lets support turn a feature off for one customer having trouble without touching anyone else. A flag used for an A/B test where two groups of users run different code paths so the team can compare results.
The catch is that flags aren't free. Every flag is a branch in the code, an if this, else that. And old flags that nobody removes pile up into code that's hard to follow. A flag left in by accident, still checked in some corner of the codebase long after the decision was made, is a common source of confusing bugs. Teams that use flags well usually clean them up once a decision is final, the same way they'd clean up a temporary debug log. So when you hear that something is deployed but not released yet, this is usually why. The code already made it to production. Someone just hasn't flipped the switch.
A mobile app calls an endpoint that returns a customer's name as a single field. The backend team decides that's messy and changes it to two fields, first name and last name in the same response. They deploy it. Within minutes the app is crashing for anyone who hasn't updated it because it's still looking for the old field and it isn't there anymore. Nothing was wrong with the new shape. The problem is that the old mobile app was never updated to expect it, and apps don't update themselves the moment a server changes. Someone is always running older code against your newest API, a phone that hasn't auto updated, a partner's system that integrates with you, a script someone wrote last year that still works.
That's what backward compatibility means. A change is backward compatible when the old callers keep working exactly as before, even though something changed underneath. Some changes are naturally safe. Adding a new optional field usually doesn't break anyone because old code just ignores fields it doesn't recognize. Renaming a field, removing one, or changing what a field means are the changes that break old callers because they expected something specific and now it's gone or different. When a breaking change is unavoidable, teams usually version the API instead of changing it in place. That might mean a version number in the URL, like a path that says v1 versus v2, or a version noted in a request header.
Old callers keep hitting V1 and keep working. New callers can move to V2 once they're ready. The old version doesn't disappear immediately. It usually sticks around for a deprecation window, often announced well in advance, giving everyone time to move before it's finally turned off. This is why a seemingly simple request, just rename this field, is rarely simple in a real system. It isn't about the code being hard to write. It's about every caller you can't see and don't control still depending on the shape you're about to change. Let's recap module six. It was a long one, so here's where your change has been.
It got turned into a package, often a container image. A pipeline checked it and moved it along, so nobody had to copy files by hand. The settings stayed outside the code, so the same build could run in test and in production. When it went live, the team watched whether the app stayed healthy. If it didn't, they had a way back. You also saw how teams lower the risk of a change. Feature flags are one way, and keeping an API working for older callers is another. And you picked up the security, privacy, and accessibility habits that stay with you on every change you make. Through all of this, we kept saying your code runs on a server or in production.
We haven't said much about where those servers are or who looks after them. For a lot of companies, the answer is the cloud. And that's module seven. Welcome to module seven. You've heard the word cloud a few times by now. Let's see what it really means. We'll go through the few building blocks most cloud apps use and how much of the work you can hand to the provider. When an app grows, you'll hear words like scaling and availability, so we'll explain those too. Then it gets practical. You'll see what a developer really touches in the cloud and how a forgotten server turns into a bill. The last part is about you.
We'll look at the different jobs around all this, and you'll get a way to tell one might suit you. By the end of this module, you'll be able to say what it means for an app to run in the cloud. You'll also know which parts of it you deal with yourself. Let's get into it. The cloud sounds like some completely different kind of technology. It isn't. At a basic level, the cloud is still computers, storage, networks, and databases. The difference is that instead of your company buying physical servers, putting them in a data center, and managing everything yourself, you can rent those resources from a cloud provider.
Companies like AWS, Azure, and Google Cloud operate huge data centers filled with infrastructure. You request what you need through their platform, maybe a virtual machine, some object storage, a managed database, or a serverless function that just runs your code without you managing a server at all. You use the service, configure it, and pay based on the service and usage model. For example, imagine you're building an online shopping application. You might host the application on a virtual machine, store product images in cloud storage, and use a managed database to store customer and order information.
These services work together to support the same application. You can also scale resources as your needs change. If more customers start using your application, you can increase capacity or configure certain services to scale automatically depending on the architecture. Another important difference is that you don't always have to manage the underlying infrastructure yourself. With managed services, the cloud provider handles many operational tasks, allowing your team to focus more on building and maintaining the application. So when someone says our application runs in the cloud, it doesn't mean the application is floating somewhere.
It means the application is running on infrastructure provided through a cloud platform. You don't need to memorize hundreds of cloud services. Start with the basic building blocks. Compute is where your application actually runs. That could be a virtual machine, a container platform, a serverless function, or another compute service. Storage is where you keep files and objects, things like images, videos, backups, and documents. Databases store your application's actual data, customers, orders, products, transactions, and so on. And networking is what connects all these pieces together, controlling how traffic moves between users, applications, databases, and other services.
For example, imagine an online shopping application. Compute runs the application. The database stores customer and order details. Storage holds product images, and networking allows customers to access everything through their browsers. A very simple application might just have users hitting an application, which talks to a database and maybe some object storage. A larger application usually adds more pieces in front of and around that. A load balancer spreading traffic across multiple copies of the application, a cache sitting in front of the database to speed things up, and storage handling the larger files.
Each additional component usually solves a specific problem. A load balancer helps distribute incoming traffic. A cache reduces repeated requests to the database, and additional application instances help handle more users. As the application grows, you might also introduce monitoring to track its health, identity services to control who can access it, and backup systems to help recover from failures. You don't need to understand every service yet. What matters is that cloud applications are usually built by combining these same few building blocks, just at different scales. Here's one of the biggest advantages of the cloud.
You don't always have to manage the underlying infrastructure yourself. Let's say your application needs a database. One option is to run that database yourself on a virtual machine. Now you're the one responsible for updates, backups, monitoring, scaling, and keeping the operating system maintained. Another option to use a managed database service where the cloud provider handles much of that underlying infrastructure for you, so your team can focus more on the database and the application itself. Of course, managed doesn't mean the provider handles absolutely everything. Your team may still be responsible for database access, data security, query performance, and deciding how backups and recovery should work.
That same idea shows up across cloud services, and you'll often hear three terms for it. Infrastructure as a service, or IaaS, means you manage more of the infrastructure yourself. Platform as a service, or PaaS, means the provider manages more of the underlying platform for you. And software as a service, or SaaS, means you simply use the finished software. Your company might use Microsoft 365, for example, without managing a single server that runs it. Think about it this way. With IaaS, you get more control but take on more operational responsibility. With PaaS, you spend less time managing the platform.
With SaaS, you use an application that's already built and maintained by the provider. The right choice depends on what you're building, how much control you need, your team's expertise, and how much operational work you're prepared to take on. The important lesson isn't memorizing those three letters. It's understanding how much infrastructure your team is actually responsible for managing. Cloud platforms become especially useful when an application grows. Let's say your application normally has 1,000 users. Then a marketing campaign suddenly brings in 100,000. Your system needs to handle that jump in traffic, and that's where scaling comes in.
Adding more copies of your application, giving existing ones more resources, or adding caching to absorb the extra load. There are two common approaches to scaling. Vertical scaling means giving an existing server more resources, such as CPU and memory. Horizontal scaling means adding more instances of the application so the workload can be shared across them. You'll also hear the word availability. Businesses don't want their application to go down just because one server failed. So cloud architectures often spread things across multiple instances, zones, and regions with backups in place, specifically to reduce the impact when something does fail.
For example, if one application instance becomes unhealthy, a load balancer can direct traffic to other healthy instances. This helps keep the application available while the team investigates the failure. However, simply running multiple instances doesn't guarantee high availability. The architecture also needs to account for dependencies, database failures, network issues, and other potential points of failure. And then there's cost. Cloud infrastructure isn't free. Compute, storage, networking, and databases all come with a price tag attached. So developers eventually start thinking about something beyond does this code work?
They also start asking how much does this application actually cost to run? That's a very real part of modern software engineering. You might be wondering, am I expected to become a cloud administrator as a developer? Not necessarily. Your role depends on the company and the team. But even application developers commonly interact with cloud systems day to day. You'll open up application logs to see what happened, check the status of the deployment, look at environment variables, glance at metrics, and confirm whether a service is actually healthy. When something breaks, you might check database connectivity, dig into why a deployment failed, or investigate why an API suddenly started returning errors.
For example, if an API suddenly becomes slow, you might check its response times, look for errors in the logs, and see whether the database or another dependent service is causing the delay. You may also use cloud dashboards to understand resource usage, identify unhealthy services, and determine whether an issue started after a recent deployment. These clues help you narrow down the problem before making changes. So you don't necessarily need to know every cloud service that exists. You need to understand how your application fits into the cloud environment around it, and that's becoming a basic part of working in IT.
There's one more part of that environment worth understanding early because it has nothing to do with whether your code works, what it costs to keep running. Someone spins up a cloud server to test something on a Friday afternoon. They forget about it over the weekend. On Monday, a message shows up in a shared channel asking whose instance has been running since Friday. This happens often enough in real companies that most of them build small habits around it. Cloud resources are billed by usage, not by a fixed yearly fee the way older on-site hardware often was. A server, a database, or a block of storage keeps costing money for every hour it exists, whether or not anyone is actually using it.
Cloud infrastructure is appealing because you can spin something up in minutes. That same convenience is exactly what makes it easy to accidentally leave something running. Here's the simplest habit and one of the first things many developers are told on day one at a company that takes the cloud seriously. Stop or delete anything you spun up for testing once you're done with it, especially before a weekend. It sounds almost too obvious to mention, and it's also one of the most repeated pieces of advice in real engineering onboarding because the mistake is so easy to make and so visible when it happens.
Most cloud providers also offer tagging, a way of labeling resources with who created them and what project they belong to. Many also offer budgets or alerts that notify someone when spending crosses a threshold. These exist specifically because which team's resource is this and why is it still running is a common enough question that it needed tooling, not just good intentions. Cost isn't usually a developer's main job, but it's part of the judgment that separates someone who thinks only about whether code works from someone who thinks about what it costs to keep working. A feature that works perfectly and quietly runs up an unnecessary bill every month is still a problem, just one that shows up on a different kind of dashboard.
That same judgment, knowing which parts of the job are actually yours, is worth applying to your career path too, not just your cloud bill. Should I become a DevOps engineer is a question a lot of developers ask without being totally sure what the job actually involves day-to-day versus what a job title just sounds like it should involve. These roles overlap more than their name suggest and the boundaries shift from company to company. So treat what follows as a rough map, not a strict definition. Start with the one you already know. A software developer mainly writes the application itself, the features customers actually interact with.
A DevOps engineer is working on a different layer. They focus on the systems that build, test, and deploy that application. That means the pipelines, the infrastructure, and the automation that gets code from a developer's machine into production reliably. Then there's site reliability engineering, usually shortened to SRE. It grew out of a similar need, but it leans further toward keeping things that already exist running well. That means deciding how reliable a service needs to be, watching for when it isn't, and often writing code that cuts down on manual, repetitive, operational work. Platform engineering is a newer, related focus again, building the internal tools and self-service systems that let other developers deploy and operate their own services without needing deep infrastructure expertise themselves.
In a lot of companies, that's what lets a growing engineering team avoid needing a DevOps specialist embedded in single team. And DevSecOps takes that same DevOps idea, the build and deploy pipeline, and folds security checks directly into it. It scans code and dependencies for known vulnerabilities automatically as part of every change instead of treating security as a separate review bolted on at the end. None of these are strictly more advanced than writing application code, despite how the industry sometimes talks about them. They're different focuses on different parts of the same system.
The feature itself, the pipeline that ships it, the infrastructure it runs on, the reliability of all of it, and the security of all of it. Plenty of developers move between these focuses more than once across a career, and plenty of companies blend several of these responsibilities into a single role, especially smaller ones. If you're trying to decide what to lean toward, a reasonable question to ask yourself is which part of a production incident you find most interesting. If it's why did this specific feature behave wrong, that's closer to application development. If it's why did our deployment pipeline let this through, that's closer to DevOps.
If it's why didn't we catch this was getting slower weeks before it broke, that's closer to SRE. There's no wrong answer here, and the honest truth is you don't have to know yet. Most people figure this out by actually doing the work for a while, not by picking a lane before their first job even starts. Let's recap module seven. The cloud is still computers, storage, networks, and databases, and you rent them instead of buying them. Most cloud apps use the same few building blocks, and how much you manage yourself depends on the services you choose. You saw two ways to scale and why extra copies alone don't guarantee an app stays up.
You also saw what a developer really touches in the cloud, like logs, deployments, and metrics. And anything you leave running keeps costing money. Then we looked at roles like DevOps, SRE, and platform engineering. You don't have to pick one yet. Whichever you lean toward, one change is reaching all of them. And module eight is about that change. Welcome to module eight. You've now seen the whole route from a ticket to an app running in the cloud. There's one question you've probably been asking for a while. AI tools can write code now, so does any of this still matter? We'll start with what these tools can do today and where developers use them on normal tickets.
You'll also see how they get things wrong in ways that are hard to notice. Then you'll read through one AI written change with me and look for the problems yourself. The last part steps away from the code editor. It looks at other roles on a team and at how companies are changing the way they plan their work. By the end of this module, you'll be able to check an AI written change instead of just accepting it. Let's start with today's tools. There was a time when AI and coding just meant autocomplete. It finished your line, maybe suggested a small function. That's not what it means anymore. Today, developers work inside AI native IDEs like Cursor, Claude Code, and Copilot's agent mode.
These tools don't just suggest a line. You can hand them a task and they'll read across your codebase, edit multiple files, run your tests, see what failed, and try again, mostly on their own. Think about what that means in practice. A task that once required you to jump between files, trace dependencies, make changes, and run tests manually can now be handled by an AI agent in one workflow. That's a real jump in capability. But here's the part that hasn't changed. These tools only know what's inside their context. They don't actually know why a workaround exists in your billing code or what a stakeholder really meant by a vague ticket or which obvious refactor will quietly break a rule nobody wrote down anywhere.
And even when the code looks clean and the tests pass, there can still be a problem. The tests might not cover that business rule or the agent might have misunderstood what the feature was supposed to do in the first place. Let's say you have a five-year-old application with thousands of files, internal APIs, business rules, and assumptions nobody documented. You can hand the whole task to an agent and get something that runs. That doesn't mean it's correct. You still need to understand the problem, give the tool the right context, and actually review what comes back before it ships. This is why understanding the codebase still matters.
The better you understand the system, the better you can guide the agent, spot mistakes, and decide whether its solution is actually safe to release. So the useful mindset isn't the AI will handle this for me now. It's the AI can do a lot more of the work, which means my job has shifted from typing code to reviewing and directing it, and I'm still the one responsible for the result. Let's take a normal development task. You receive a ticket saying add validation to the customer registration API. In an AI-native IDE, a developer might just describe that task directly to the agent. It can go explore the existing code on its own, find the registration endpoint, draft the validation logic, write a few tests, run them, and fix anything that fails, often before the developer has read a single line of the existing file.
But notice what's still true. Someone still had to write that ticket clearly. Someone still decided what valid actually means for this business, whether an empty phone number should be allowed, whether existing users are grandfathered in. The agent can execute a well-scoped task fast. It can't decide what the right scope is. And this is where experience makes a difference. A developer who understands the business can spot missing requirements, ask the right questions, and give the agent enough context to avoid making assumptions that could cause problems later. And once the agent produces a change, the developer still opens the diff, reads through what actually changed across those files, checks it against the ticket, and sends it through code review like anything else.
That review matters because the agent might solve the immediate problem while introducing a different one, as breaking an existing API contract or changing how another part of the application behaves. So the workflow hasn't disappeared, it's shifted. Less time typing the implementation, more time scoping the task clearly upfront and reviewing the result carefully afterward. Experienced developers know exactly where that balance sits, when to just let the agent run, and when a task is sensitive enough that they need to slow down and drive it themselves. Here's the part beginners really need to understand, and it matters even more now that AI can touch your whole codebase at once.
An agent can change 10 files and every single test can pass and the change can still be wrong. It might quietly break a business rule that wasn't written down anywhere. It might clean up a piece of logic that looked redundant but was actually handling a rare, important case. It might introduce a security gap while technically solving the ticket exactly as written. And this is the tricky part. A small AI suggestion that's wrong is easy to spot. A large, multi-file AI change that's mostly right and subtly wrong is much harder to catch because it looks thorough. It ran. The tests passed. It reads like something a careful engineer would write.
So when you're reviewing AI-generated code, don't stop at asking whether the tests passed. Ask yourself what the code actually changed, why those changes were necessary, and whether anything else in the application depends on the old behavior. That's exactly why review matters more now, not less. You still read through what changed, you still run it yourself, you still check it against the actual business requirement, and you still ask what this change assumed that might not be true. Approving an AI-generated change you don't doesn't save you time. It just moves the hard part to whenever it eventually breaks, except now you're debugging code you never actually understood in the first place.
If you take one sentence out of this section, make it this one. The better your fundamentals are, the more useful an AI native IDE becomes. Here's why. An agent hands you a change across six files using a pattern you've never seen. If you don't understand programming, APIs, databases, and Git, you'll accept it and hope. If you do understand them, you can read that diff, spot the bad assumption, ask the agent to fix just that part, and judge whether the whole approach even fits your application. And the same principle applies when something goes wrong. If you understand how the pieces fit together, you can trace the problem, give the agent useful feedback, and guide it toward a better solution instead of blindly asking it to try again.
Take Git as another example. If you understand branches, commits, and diffs, you can see exactly what the agent changed, compare it with the original implementation, and undo a change if something goes wrong. Without that knowledge, you're relying on the tool without knowing how to recover when things break. The same goes for databases and APIs. When an agent changes a database query or modifies an API response, your fundamentals help you recognize whether the change could affect performance, break another service, or cause problems for existing users. You don't need to memorize every programming language or understand every framework in advance, but you do need a solid foundation because that's what helps you separate a good solution from one that only looks good.
Same tool, completely different outcome. The difference is you. So let's actually do it. In the next lecture, we're going to look at an AI generated change together and find what's wrong with it. Let's make this real. Same ticket as before. Add email validation to customer registration. You describe it to the agent in your IDE. Two minutes later, it's done. Tests pass. Here's the change. Now, most beginners look at this and see two things. Green means added, tests are green, ship it. Let's slow down and read it the way a reviewer reads it. Start at the top. The agent added a function called is valid email.
Good. It's reusable. That's what we'd want. Inside, there's a pattern that checks the email format. Letters and numbers, an at sign, a domain, a dot, a couple of letters. Looks reasonable. Look closer at the characters it allows before the at sign. Letters, numbers, dots, underscores, hyphens. Now think about real email addresses. Have you ever seen one with a plus sign in it? Like name plus newsletter at gmail.com? Lots of people use those. They're completely valid, and this pattern rejects them. Every test passed because the agent also wrote the tests, and it only tested addresses it already believed were valid.
That's the trap. The tests agreed with the code because the same assumption wrote both. Keep going. The new check runs every time someone hits the registration endpoint. Now scroll to the ticket. The acceptance criteria said existing valid registrations must continue working. Does anything here touch existing users? Actually, look at where the agent put the call. It's in the shared save customer function, not the register function. That function also runs when an existing customer updates their profile. So a long time customer with a plus sign in their email would now be blocked from changing their address.
That's two problems. One is a wrong assumption inside a pattern. The other is a change in the wrong place. Neither one shows up as a red test. Both would show up as a support ticket next week. So what does the review look like? Not this is wrong. Something like this pattern rejects plus addresses which are valid. Also, the validation runs in save customer, so it affects profile updates. Can we move it to the registered path and add a test for a plus address? Then you hand that back to the agent and it'll fix it in 30 seconds. That's the whole skill. You're not competing with the tool on typing.
You're reading its work against the ticket, against the business, and against what real users actually do. You'll get a diff like this in assignment three for this section. Try to find both problems yourself before you look at the answer. Now let's zoom out because this isn't only happening to developers, and this shift isn't only happening in code editors. The same kind of AI agent is showing up across IT, summarizing a messy incident timeline for a support engineer, drafting and explaining SQL for someone on the data team, generating a first pass of test scenarios for a tester, or pulling together a project update for a manager before a meeting.
For example, a data engineer might use AI to draft a SQL query, but still needs to check whether the joins are correct and the results make sense. A tester might generate dozens of test cases in seconds, but still needs to decide whether the important edge cases are covered. The work gets faster, but knowing what good work looks like still matters. So when you enter IT today, don't think of AI as one tool bolted onto your editor. Think of it as a layer running underneath almost every role on a team, doing more of the first draft so people can spend more time deciding, reviewing, and judging whether that first draft is actually right.
And this changes what it means to be good at your job. It's no longer just about how quickly you can produce something yourself. It's also about how well you can use these tools, recognize their mistakes, and take responsibility for the final outcome. The specific tools will keep changing. The skill that doesn't go out of date is knowing when to hand something to AI, how to direct it well, and how to verify what it hands back. AI-native IDEs aren't just changing how individual developers write code. They're starting to change how entire companies plan and build software. Think about how software development has evolved over time.
Years ago, teams used waterfall, planning everything up front and building it in one long sequence. Then came Agile, breaking that into short iterative cycles. Then CICD and DevOps, automating testing and deployment so releases could happen constantly instead of once a year. AI is becoming the next layer on top of that evolution, not a replacement for it. Here's the interesting part. Now that an agent can build and test a well-defined task in minutes, the bottleneck has moved. It's no longer how fast can we write this code, it's how clearly can we define what we actually want built. Companies are realizing they need to invest more, not less, into the planning stage.
Real effort goes into defining the problem, the requirements, and what is explicitly out of scope before any agent touches the code. You might hear people call this shifting left. Strictly speaking, that phrase comes from testing. It means running your tests earlier in the process instead of at the very end, but the spirit is the same. Catch the problem while it's still cheap to fix. Why does that matter so much now? Because an AI agent follows instructions literally, and it can move very fast in the wrong direction. Give it a vague, half-finished requirement, and it will guess confidently and often incorrectly.
Give it a clear, well-scoped problem, including what's explicitly out of scope, and it can move remarkably fast in the right direction. None of this replaces human judgment. Deciding whether a problem is even worth solving or whether a product is worth building at all is still a human call. AI can execute that decision faster once it's made. It doesn't make the decision for you. You'll likely see this play out wherever you end up working. Smaller, more flexible teams, more time spent up front turning a rough idea into a clear, detailed plan, and AI native tools handling more of the actual implementation once that plan exists.
And the fundamentals you're learning in this course, understanding requirements, systems, and how the pieces fit together are exactly what makes you valuable in that kind of environment. Let's recap module eight. We started with a question, and the answer is yes. Everything you've learned still matters. An agent can read your code, change many files, and run the tests mostly on its own, but it only knows what's in its context. So a change can pass every test and still be wrong. You saw that in our review. The email check rejected valid addresses and ran in the wrong function. The agent wrote its own tests, so they passed, and neither problem showed up.
Your basics are what let you catch that. AI is changing other roles, too, and companies are spending more time on planning because a vague request can now go wrong very fast. In module nine, we leave the code for a while and look at your working day. Welcome to module nine. Where do your hours go on a real team? This is a big module, so here's what it covers. The topics are mixed together, so they won't come in this order. Some of it is about normal days. That means your meetings and what it's like to work across time zones. It also means the many hours that go into keeping older software running.
Some of it is about the bad days. That's when production has a problem or when you're the one on call. You'll also see how a team watches its systems so it can find trouble early. The rest is about you as the new person on the team. You'll learn how to ask for help, what to do when you first join, and how to write things people will read. A few topics come up twice, like team review meetings and production problems. So if something sounds familiar, you're not lost. We're just going a little deeper the second time. By the end of this module, you'll know what to expect from your days on the team.
Let's start with a normal day. A developer's day usually doesn't start with opening an editor and coding for eight straight hours. A normal day could start with a stand-up meeting where you talk about what you worked on yesterday, what you're working on today, and whether anything is blocking you. These meetings are usually short, but they help the team understand where things stand. If you're stuck waiting for another team or need help with a technical problem, this is a chance to bring it up before it delays your work further. Then you might spend the next couple of hours working on your ticket, reading existing code, searching the repository, checking a database query, running the application, looking at logs, and probably asking another developer a question at some point.
And sometimes what looks like a small task turns out to be much bigger than expected. You might discover that the code depends on another service, that the existing behavior isn't documented, or that you need to understand how an older part of the application works before you can safely make a change. Then you might have a meeting about a new requirement. Later, someone reviews your pull request and asks you to change something. You make the change, run the tests again, and update the pull request. This is also where communication becomes important. You might need to explain why you chose a particular approach, discuss an alternative with a teammate, or clarify a requirement with the person who requested the change.
Writing code is only one part of getting the right solution delivered. And then you might spend the afternoon investigating a completely different problem because something broke in another part of the system. That's normal. Some days have lots of coding. Some days have almost none. As you gain experience, you'll also get better at managing these interruptions, deciding what needs attention first, and knowing when to ask for help instead of spending hours stuck on the same problem. The job is really a combination of coding, debugging, communication, investigation, meetings, reviews, and problem solving.
You will probably hear the word standup quite a lot. A typical daily standup is a short team meeting where everyone shares what they're working on and whether they're blocked. It usually sounds something like, yesterday I finished the customer API changes. Today I'm working on the validation ticket. I'm blocked because I don't have access to the test database. That's useful because everyone gets visibility into what the team is doing. You'll also hear a handful of other terms. A sprint is a fixed period during which a team works on a set of planned work. The backlog is the list of work that may need to be done.
Planning is when the team decides what work to take on next. And a retrospective is when the team discusses what went well, what didn't, and what could improve. A retro is worth understanding properly because it's one of the few meetings built entirely around improving how the team works, not just what the team ships. It usually follows a simple pattern. What went well, what didn't, and what the team will actually try differently next sprint. The value isn't in the complaining part. It's in that last step. Walking away with one or two concrete changes rather than just a list of frustrations that gets repeated every retro with nothing changing.
As a junior, you don't need to run these meetings. You just need to actually contribute. A small process friction you noticed is exactly the kind of thing retros exist to surface. Different companies follow Scrum, Kanban, or something customized. Don't get too caught up in memorizing the terminology. The important thing is understanding that software development is a team activity. Your code is only one part of the process. And on some teams, that daily standup doesn't even happen live because the team isn't all working the same hours to begin with. A growing number of teams aren't all sitting in the same office or even the same country.
You might have a teammate finishing their day as your starts. That changes how the team actually communicates, and it's worth understanding early. The biggest shift is that async, meaning not expecting an immediate reply, often becomes the default instead of the exception. If you ask a one-line question like, does this work? To someone 8 hours ahead of you, you might not hear back until tomorrow. And then you'll likely need another full day for the follow-up question you didn't think to ask up front. The fix is writing messages with enough context the first time, what you're trying to do, what you've already tried, and exactly what you need from them.
So a single reply can actually unblock you instead of starting a slow back and forth. For example, instead of saying, I'm getting an error, can you help? Explain which application you're working on, what you were trying to do, the error you received, and what you've already checked. If you can include a relevant log or screenshot, even better. Your teammate can investigate while you're offline rather than spending another day just trying to understand the problem. Some distributed teams also run standup asynchronously. Everyone posts their yesterday, today, and blockers in a channel instead of talking live precisely because there's no single time that works for everyone.
That's not a lesser version of a standup. It's a reasonable adaptation once a team is genuinely spread across time zones. This also means you need to get comfortable making progress independently. If you're blocked on one task, you might document what you found, move to another ticket, or investigate a separate part of the problem while you wait for a response. That way, your entire day doesn't depend on someone else being available. And here's something worth internalizing early. A fast reply doesn't make you look more dedicated, and a slower one, within reason, doesn't make you look less committed.
What actually matters on a distributed team is whether your communication gives people what they need without requiring you to be online at the same moment they are. Whichever hours your team works, a lot of what actually fills those hours isn't building new features at all. It's maintenance. Here's something that surprises many beginners. Not every developer spends their time building exciting new features. A lot of software work is maintenance. You might fix a bug that appeared after a release, update an old dependency, improve a slow database query, tweak a configuration value, look into a customer complaint, add some logging, clean out unused code, upgrade a framework version, or modify a feature that's existed for five years.
And sometimes the fix itself is surprisingly small. A single configuration change might resolve the issue, but finding that setting could take hours of investigation. That's because understanding why something broke is often harder than actually fixing it. That might sound less exciting than building something brand new, but it's a huge part of how real software works. Companies have applications that have been running for years. Those applications make money, customers depend on them, and someone has to keep them working. Think about an online banking application, for example. It might have been built years ago, but customers still use it every day to check balances, transfer money, and pay bills.
The team can't simply stop everything and rebuild the entire application whenever a better technology comes along. They need to improve it carefully without breaking the things people already rely on. A lot of this maintenance work exists because of something you'll hear called technical debt. It's not necessarily bad code. It's usually a shortcut that made sense at the time. A quick fix shipped to hit a deadline or a design decision that worked fine until the application grew past what it was originally built for. Like financial debt, it's not inherently a disaster, but it accumulates interest.
The longer it sits unaddressed, the slower and riskier future changes become. Part of maintenance work is paying some of that down deliberately instead of only ever adding more of it. For example, imagine a piece of code that works perfectly well today, but is difficult to understand and has no tests. Every time someone needs to change it, they have to spend extra time figuring out how it works and checking that nothing else breaks. Adding tests and simplifying that code might not deliver a new feature, but it can make every future change safer and faster. So when you get your first job, don't be surprised if your first ticket is fix this existing issue instead of build this amazing new application.
That's normal software development. Now let's talk about one of the most stressful situations for a developer. Something breaks in production. Maybe customers can't log in, maybe an API is suddenly returning errors, maybe orders are getting stuck, or maybe a recent deployment introduced a problem nobody caught. The first priority isn't writing new code, it's understanding the impact. What's actually broken? How many users are affected? When it started? What changed recently? And what the logs show? Depending on what they find, the team might roll back the deployment, disable a feature, fix a bad configuration value, or ship a quick hotfix to stop the bleeding.
After the problem is under control, the team usually investigates why it happened and what can prevent it from happening again. This step is often called a root cause analysis or a post-incident review. A useful one usually asks a chain of questions rather than stopping at the first answer. The deployment caused it, sure. But why did that change get through review and testing without anyone catching it? And what would need to be true for it to get caught next time? The output isn't just a written explanation, it's a short list of concrete follow-up actions. Better test coverage here, an alert that should have fired sooner there, that someone actually owns and follows up on.
You'll hear terms like incident, hotfix, rollback, root cause, and post-incident review. These aren't just technical words. They describe how teams respond when real systems fail. And eventually, every developer learns that production problems are just part of working with software. And sometimes that problem shows up outside of normal working hours entirely, which is where on call comes in. At some point, you'll hear that a teammate is on call this week. And if you've never experienced it, the phrase alone can sound intimidating. It's worth understanding what it actually involves before you ever get anywhere near it yourself.
On call means that for a set period, usually a week, someone on the team is the person who gets alerted if something breaks outside of normal working hours. A server issue at 2:00 a.m., a spike of errors on a weekend. It exists because real systems don't stop running just because the office is closed, and someone needs to be reachable if something genuinely urgent happens. For example, imagine an online shopping application suddenly stops processing payments late at night. The on call engineer might receive an alert, check the monitoring dashboard, look at the error logs, and work out whether the issue is affecting all customers or just a small part of the system.
The immediate priority is to understand the impact and restore the service safely, not to rush into a random fix. For a junior developer, on call is rarely something you're handed on day one. Most teams ease people into it gradually, often shadowing a more experienced teammate first, watching how they respond to an alert before ever being the primary responder yourself. And being on call doesn't mean you're expected to fix every problem alone at 2:00 a.m. The actual job in that moment is usually to acknowledge the alert, assess how serious it is, and escalate to someone with more context if it's beyond what you can safely handle.
Knowing when to wake someone else up is a completely legitimate on call skill, not a failure. You'll also find that teams prepare for these situations before anything goes wrong. They document common issues, define who should be contacted, and create runbooks that explain the first checks to perform. Good monitoring and clear instructions make incidents easier to handle, especially when the person responding didn't build the part of the system that's failing. Not every company has on-call and not every role includes it. It depends heavily on what you're building and how critical it is that it stays running.
But if your team does have it, know that it's a rotation. It's usually gradual, and asking for help in the middle of an alert is exactly what it's there for. And that willingness to ask for help isn't just an on-call skill. It's one of the most important habits you can build in your first few months, on-call or not. Here's a skill that can save a beginner weeks of frustration. Knowing when to ask for help. When you're new, it's easy to think I should figure this out myself. So you spend 3 hours trying random things. That's usually worse than spending 10 minutes asking a good question. But before you ask, there's a quick order of operations that experienced developers follow without thinking about it.
First, read the actual error message, all of it, not just the first line. Second, check the project's own documentation or readme because a lot of bugs are setup steps you skipped. Third, search the exact error text in quotes because someone has almost certainly hit it before. Fourth, ask an AI assistant to explain the error and treat the answer as a lead, not a verdict. And then, if you're still stuck after 15 or 20 minutes, ask a person. One thing worth remembering is that the 15 or 20 minutes isn't a strict timer. Some problems genuinely need longer investigation while others are worth escalating sooner, especially if they affect production or block the rest of the team.
The goal isn't to solve everything alone. It's to make a effort before getting someone else involved. That sequence matters because of what it gives you when you finally do ask, a list of what you already tried. The important part is how you ask. Instead of just saying, it's not working, can you help? Try something like, I'm working on the customer API. The request reaches the service, but the database call is timing out. I checked the logs and the timeout starts right after the query runs. I haven't changed the database configuration. Do you know whether this environment has had this issue before?
Notice that this question gives your teammates somewhere to start. They can look at the database connection, check whether the environment has a known issue, or suggest the next investigation step. You're not asking them to solve a mystery with no clues. That's a much better question. You've explained what you're doing, what you expected, what actually happened, and what you've already checked. And when someone helps you solve the problem, take a moment to understand the fix. Write down what caused the issue, why the solution worked, and how you might recognize the same problem next time. Otherwise, you risk getting stuck on the exact same thing a few weeks later.
Experienced developers generally don't expect beginners to know everything. They do expect you to investigate before asking. Your first few weeks at a new company can feel overwhelming. You'll hear a hundred terms you've never seen, and you'll understand maybe half of most conversations. That's normal. So instead of trying to understand everything, here's what experienced developers actually do in week one. First, get the application running on your machine, not perfectly, just running. Clone the repository, follow the README, and when the setup steps are out of date, and they usually are, write down every step that didn't work.
Fixing that README is often a great first pull request. Second, find the five places where everything happens, where the tickets live, where the code lives, where the pipeline runs, where the application is deployed, and where the logs are. If you know those five, you can follow almost any conversation on the team. Third, watch one change go all the way through. Pick any teammate's pull request and follow it. The review comments, the merge, the pipeline, the deployment. You'll learn more about your team's real workflow from one PR than from any onboarding document. Fourth, take a small ticket early.
A typo fix, a log message, a tiny bug. The point isn't the ticket. The point is going through the whole workflow once, end to end, while the stakes are low. And fifth, keep a personal glossary. Every internal system name, every acronym, every oh, that's the service that handles payments moment. Write it down. In a month, that document is the map of the system in your head. And that's how confidence actually develops. Not by knowing everything, by gradually needing less context to understand what's going on around you. That confidence gets tested for real the first time something breaks badly enough that the whole team notices.
Somewhere, a customer is staring at an error page right now, and your team just found out. What happens in the next 10 minutes matters more than what happens in the next 10 hours. Most teams grade how serious a problem is using a severity level, often shortened to SEV. SEV one is the worst. A full outage or data loss affecting many customers. SEV three or SEV four is a minor issue affecting a few people with an easy workaround. The severity decides how loudly to raise the alarm. It decides whether to wake people up overnight, and it decides whether leadership needs to know immediately. Getting the severity roughly right quickly matters more than getting it exactly right.
A SEV one called in as a SEV three can sit ignored while customers suffer. The reverse just means someone double checks and downgrades it. During an active incident, the instinct of a new developer is often to immediately start trying fixes. A more useful first move is almost always to communicate. Say what you know, say what you don't know yet, say what you're checking next. Often in a dedicated channel, everyone affected can watch. This isn't bureaucracy for its own sake. An incident with several people quietly trying different fixes in isolation is slower and more dangerous than one person stating clearly, I'm about to restart this service before doing it.
Once the immediate fire is out, most teams hold a postmortem, a written account of what happened, why, and what will change so it's less likely to happen again. The standard the better ones hold to is blameless. The document describes the sequence of events and the gaps in the system that allowed it, not which person to blame. This isn't about being nice. A team where admitting, I pushed the change that caused this leads to blame, is a team where people start hiding problems instead of reporting them early, which makes the next incident worse, not better. A good postmortem usually separates two different questions.
The first is what happened in plain specific detail. The sequence of events, timestamps, the exact symptoms. The second is what will change. Is there a test that should have caught this? A check missing from the deploy pipeline? An alert that should have fired sooner but didn't? The second part is where the real value is. A postmortem that just describes the outage without naming a concrete follow-up tends to repeat itself eventually. If you're newer on the team, you'll often be reading more postmortems than writing them at first. Read them anyway. They're one of the fastest ways to learn how a system actually behaves under stress instead of how it's supposed to behave on a good day.
A good postmortem is also, quietly, a piece of writing. And the habits that make it useful apply to a lot of what you'll write day to day. You finish a feature and three weeks later, someone asks you the exact question your own commit message could have answered, if only you'd written one worth reading. Most documentation problems aren't about writing too little. They're about writing in a way nobody comes back to. A giant README nobody updates after the first month helps nobody. A short, specific note placed where someone will actually look for it helps a lot. Start with the README every project seems to have and few people maintain.
At minimum, it should answer three questions fast. What is this? How do I run it? Where do I go if something's broken? If a new teammate still has to ask you those three questions after reading it, the README isn't doing its job yet, no matter how long it is. For a bigger decision, some teams keep a short document often called an ADR, an Architecture Decision Record. It covers what problem you were solving, what options you considered, and why you picked the one you did. The value isn't really for today. It's for the person six months from now, possibly you, wondering why on earth it was done this way, who would otherwise have to guess or ask around.
Async communication, a message in a channel instead of a conversation in person, has its own habit worth building. Say the conclusion first, then the reasoning, not the other way around. Going with option B, here's why, reads in two seconds. A message that opens with several paragraphs of context before finally landing on the point often gets skimmed, misread, or answered incorrectly by someone who stopped reading halfway through. If someone needs to act on what you wrote, make the action obvious without requiring them to read the whole thing first. The same applies to status updates, especially during something ongoing.
Still looking into it, said once with silence after, reads very differently from the same words repeated every so often along with what's been ruled out so far. The second version costs you almost nothing extra to write and tells everyone watching that progress is actually happening. None of this requires good writing in some formal sense. It requires one question before you hit send or save. If someone read only the first sentence of this, would they still know what to do next? If the answer is no, that sentence needs to move to the top. Standups are the meeting most people picture when they hear Scrum, but a team running sprints usually has two other recurring meetings that shape the work just as much, and new developers often walk into both without knowing what to expect.
Sprint planning happens at the start of each sprint, a fixed chunk of time, often one or two weeks, that the team is committing to. The team looks at the backlog, the pile of tickets waiting to be worked on, and decides what fits into this sprint. For each ticket, someone explains what it involves, and the team estimates how much effort it takes, often in story points rather than hours. This is where you'll hear a ticket argued over for 10 minutes, not because the task is hard, but because nobody's sure yet what done actually means for it. Planning goes better when tickets are specific. Fix the login page invites that confusion.
Fix the login page so it shows an error message when the password is wrong, doesn't. A retro, short for retrospective, happens at the end of the sprint after the work is done. It isn't about reviewing the product, it's about reviewing how the team worked. A common format asks three questions. What went well? What didn't? What should we change going forward? A flaky test that wasted a day, a ticket that turned out way bigger than estimated, a deployment that went smoothly for once. All of that is retro material. The part that makes retros actually useful is psychological safety, the sense that you can say, I underestimated this, or that process didn't work without it being held against you.
A retro where nobody says anything honest just produces the same problems again next sprint. So if you're new to a team and planning feels like arguing over tickets and retro feels like complaining with structure, that's normal. Both are the team's way of getting a little better at predicting and working together, sprint at a time. A service has been quietly failing for 20 minutes before anyone notices, not because it crashed, but because one in every 20 requests was returning an error and nobody was watching that number. The service looked up. It just wasn't fully working. This is the gap that monitoring exists to close.
Shipping code and watching it work are two different skills, and a team that's good at the first but blind to the second finds out about problems from angry users instead of from their own tools. At its simplest, monitoring means collecting numbers about a running system over time. The most common ones are error rate, how often requests fail, latency, how long requests take to come back, and traffic, how many requests are coming in at all. A dashboard turns those numbers into a graph you can glance at instead of a wall of log lines you'd have to read one by one. An alert is a rule that watches one of those graphs and notifies someone when it crosses a line that matters, error rate above a certain percentage or latency above a certain number of seconds.
Good alerts are specific enough to act on. A vague alert that fires constantly for things nobody needs to act on trains people to ignore it, which means the one time it matters it gets ignored, too. Monitoring is different from the incident response you may have heard about elsewhere. Incident response is what happens after something is clearly broken and everyone knows it. Monitoring is what catches the problem quietly, often before users notice, sometimes before it becomes an incident at all. You don't need to build any of this yourself as a junior developer, but you will be expected to glance at a dashboard before and after you deploy something and to know that a quiet dashboard is a good sign, not a boring one.
Let's recap module nine. A normal day is a mix of coding, reading, meetings, and questions. You learned what those meetings are for and how teams in different time zones keep work moving by writing clearly the first time. And you saw how much of the job is looking after software that already exists. Then came the bad days. When production breaks, you find out the impact first, and you tell people what you're doing before you try a fix. For a new developer, on call usually means checking the alert and bringing in the right person if it's too big to handle safely. A blameless post mortem turns a failure into real changes, and good monitoring can catch trouble before customers do.
For your own start, you now have an order to follow before asking for help. You also have five things to do in your first weeks, and you can write notes and updates that put the point first. That covers the work itself. Module 10 is about your place in all of this. Welcome to module 10, the last one. It's about everything around the work. That means the company you join, the people you work with, and where all of it can take you. We'll start before you're even hired. You'll see the kinds of companies out there, the roles on a team, and what a company really expects from a junior. From there, we get to the harder side of working with people.
Someone will reject your work. Someone else will want it sooner than you can safely ship it. And some days, you'll get one more task when you're already too busy. You'll know what to say when that happens. After that, the focus moves to your own growth. You'll see how to make sure your work gets noticed and how to use your time with your manager well. You'll learn to talk with people who don't write code, and you'll see where you fit in the company and how to find someone who can guide you. By the end of this module, you'll know how to handle the people side of the job. You'll also know how to look after your own growth.
Let's begin with the choice you'll run into as as as you start applying. One thing you'll hear a lot when you start looking for IT jobs is product company versus service company. A product company builds and operates its own software product, a banking platform, an e-commerce app, a developer tool, a SaaS product. The team is usually focused on improving and maintaining that one product over time. For example, imagine a company that builds a project management tool used by thousands of businesses. Its developers might spend months improving the same product, adding features, fixing bugs, and responding to customer feedback.
Over time, they get to understand the product and its architecture in considerable depth. A service company works differently. It provides technology services to clients. So you might work on a banking project for one client and a retail project for another right after. That can mean jumping between different technologies, industries, and project environments. Imagine you're working for a service company and your client is a bank. You might help build an API, migrate data to the cloud, or maintain an existing application. If the project ends and you're assigned to a retail client, you could find yourself working with a completely different technology stack and business domain.
That variety can be a valuable learning experience, especially early in your career. But don't oversimplify this into product is good, service is bad. That's not how the real world works. A great team in a service company can give you more practical experience than a poorly managed product team. There's also some overlap between the two. Product companies hire consultants and external teams, while service companies sometimes build and maintain systems for the same client for many years. The actual work can matter more than the category the company falls into. What actually matters is what you'll be working on day to day, what technology you'll use, whether you'll touch real production systems, whether you'll actually get code reviews, whether there are experienced people around you, and whether you'll own work that matters.
Those questions tell you a lot more than the label on the company. And your first job doesn't lock you into one path. You can start in one type of company, build real experience, and move later. Another thing beginners often struggle with is understanding all the different roles inside an IT team. You'll hear titles like software developer, front end developer, back end developer, data engineer, data analyst, DevOps engineer, cloud engineer, QA engineer, security engineer, product manager, and plenty more. These roles overlap at some companies, but they generally focus on different parts of the system.
A front end developer focuses heavily on what users actually interact with. A back end developer works more with APIs, business logic, databases, and services. A data engineer builds the systems that collect, transform, move, and prepare data. A DevOps or platform engineer usually focuses on infrastructure, deployment, automation, and reliability. And a QA engineer focuses on validating software and catching problems before users ever see them. Let's take an online shopping application as an example. The front end developer builds the product pages and shopping cart that customers see. The back end developer handles things like orders, payments, and customer accounts.
The data engineer makes sure sales and customer data flows into systems where it can be analyzed, while the QA engineer tests whether the checkout process works correctly, including situations where a payment fails. Meanwhile, the cloud or platform engineer helps keep the application running in the right environment, manages deployment pipelines, and makes sure the infrastructure can handle the workload. The security engineer looks for vulnerabilities and helps protect customer information. Each role contributes to making the same application work reliably and safely. Then there are roles outside direct development entirely.
Product managers who think about what should be built and why, designers who shape the user experience, and project or delivery people who help coordinate the work. For example, before a team builds a new checkout feature, the product manager might define the customer problem. The designer works out how the experience should look, and the developers figure out how to implement it. The QA engineer validates the finished feature, while other team members help make sure it can be deployed and operated reliably. These people are solving different parts of the same problem. The important thing is that real software is rarely built by one person.
A production application is usually the result of a lot of different roles working together. So when you join a company, don't only learn who writes code, learn who does what. That makes the entire system much easier to understand. A common mistake beginners make is thinking companies expect a junior developer to know everything. Usually, they don't. Nobody expects you to know every framework, every cloud service, or every internal tool on your first day. What companies actually need from a junior is much more basic. Can you understand a requirement, read existing code, and solve a reasonably scoped problem?
Can you test your own work? Speak up clearly when you're blocked? Pick up something you've never seen before and take feedback without getting defensive about it? Think about it from the team's perspective. A senior developer can teach you how their application works or help you understand a new technology, but they need to be able to trust that you'll ask when something is unclear, check your work before handing it over, and tell them honestly when something goes wrong. Those things matter a lot more than they sound. You might not know how the company's deployment system works. That's okay. You can learn it.
But if you don't ask questions, don't test your changes, don't communicate problems, and can't take feedback, all the technical knowledge in the won't fix that. And remember, nobody expects you to learn everything overnight. You might make mistakes, misunderstand a requirement or need help with something that seems obvious to everyone else. What matters is whether you learn from those experiences and gradually become more confident working independently. So when preparing for your first job, don't focus only on collecting technologies. Build the ability to learn and work inside an existing system.
That's much closer to what your first year will actually require. And part of working inside a system is working with people who don't always agree with you. Let's talk about that. Here's a moment nobody warns you about. You finish your ticket, you're proud of it, and the Q&A engineer moves it straight back to in progress with a note, fails when the email has uppercase letters. Your first reaction is going to be a little sting. That's human. Here's the thing to understand. Q&A rejecting your ticket is not Q&A rejecting you. It's the system working exactly as designed. That bug was going to be found by somebody.
Better a teammate on Tuesday than a customer on Saturday. So what do you do? You say, good catch. You reproduce it, you fix it, and you add the uppercase case to your tests so it never comes back. That's it. The developers who get respected fast are not the ones who never get bugs. They're the ones who handle them without drama. Now the other direction. A product manager pings you. Can we just ship the registration change today? The marketing campaign starts tomorrow. Your code review isn't done. The staging tests haven't run. You're new. You want to be helpful, and just ship it sounds like being helpful.
It isn't. Here's a better answer, and you can use it word for word. I can't skip the review and staging run safely. What I can do is get it into review right now and flag it as urgent. If it passes, it can go out this afternoon. If we skip those steps and it breaks registration during the campaign, that's a worse day for everyone. Notice what that does. It doesn't say no. It says what's possible, what the risk is, and puts the decision where it belongs, which brings us to the most important rule for a junior. Decisions like that don't happen in a private chat. They happen on the ticket or in the team channel where your lead can see them.
If the product manager still wants to skip steps, that's a call for your lead to make, not you. Escalating isn't tattling. It's how the team protects both the product and you. And one more. Sometimes a senior developer will push back on your approach in code review, and you'll be sure you're right. Ask why, genuinely. Most of the time there's a reason you haven't seen yet, an old incident, a system you didn't know about. Occasionally you'll actually be right, and saying, here's what I was thinking, does that change anything? Is how you find out. Disagreement is a normal part of building software with other people.
Handle it calmly, keep it visible, and it turns into trust faster than anything else you can do. Here's something nobody puts in a job posting. Even on a healthy team, people have different incentives, different priorities, and sometimes different opinions about who should get credit for what. That's not necessarily a toxic workplace. That's just what happens whenever more than a few people work together. The question isn't how to avoid this entirely, it's how to move through it without damaging your own reputation in the process. The most reliable protection you have is keeping decisions and disagreements visible instead of private.
If a disagreement with a teammate happens in a side conversation, it can quietly turn into two different stories later. If it happens on the ticket, in the pull request, or in the team channel, everyone can see what was actually said and agreed to. This isn't about distrust. It's just a habit that protects everyone, including you. For example, suppose you suggest one approach to solving a problem, but another developer recommends something different. Instead of turning it into a personal argument, explain your reasoning, listen to theirs, and document the final decision. If the team chooses their approach, support that decision and move forward.
You don't have to win the argument to contribute something valuable. The second habit is simple, but easy to forget under pressure. Don't vent about a coworker to other coworkers. It feels satisfying in the moment, and it almost always comes back around. If someone's work or behavior is genuinely a problem, that's a conversation for your manager, calmly and factually, not a conversation for the group chat. And when you raise a concern, focus on specific behavior and its impact rather than making assumptions about someone's intentions. Saying that a missed handover delayed your work gives your manager something concrete to address.
Saying that someone is lazy or doesn't care turns the conversation into a judgment about their character. And the third habit is the one that actually builds a good reputation over time, not through impressing people, but through being consistently easy to work with, following through on what you say you'll do, giving credit to people who helped you, helping a teammate without immediately expecting something back. None of this is about being naive. It's that a reputation for being straightforward and reliable tends to open more doors than any amount of self-promotion. That doesn't mean you should quietly accept everything or take responsibility for problems that aren't yours.
You can disagree respectfully, set boundaries, and speak up when something is unfair. Being professional means handling those situations constructively, not pretending they don't exist. You don't need to win every disagreement or be liked by everyone. You need to be someone people trust to act the same way whether or not they're in the room. Staying professional through moments like this is one part of protecting your reputation. The other part is protecting your time, which is its own skill entirely. At some point, someone is going to hand you a new task while you're already juggling two others, and every instinct you have will want to say yes anyway.
As a beginner, saying yes to everything can feel like the safe choice. Often, it's actually the choice that causes the most damage later. Here's why. If you quietly take on more than you can realistically finish, one of two things happens. Something slips through with less attention than it deserved, or you end up working long hours just to keep up. Neither one is sustainable, and neither one is actually what a good manager wants from you, even if it feels like the helpful answer in the moment. And there's another problem with constantly saying yes. Your manager might assume your workload is manageable because you're never raising any concerns.
By the time a deadline slips or the quality of your work starts to suffer, the problem has already become much harder to fix. The skill isn't refusing work. It's making the trade-off visible instead of invisible. Something like, I'm currently finishing the payment ticket and reviewing a teammate's pull request. I can start this new one today, but the payment ticket would slip to tomorrow. Which would you like me to prioritize? That's not saying no. It's handing the actual decision to the person who has the full picture instead of silently overcommitting and hoping it works out. This is especially important when you're new because you might not yet know how long a task will take.
If you discover that something is more complicated than expected, communicate that early. You don't need to have the perfect solution or a new deadline ready. Just explain what you found, what remains, and where you need help. The same idea applies to your time outside of work hours. Occasionally, something urgent genuinely can't wait. But if every evening or weekend starts to feel like an emergency, that's not a personal failing to push through quietly. It's a signal worth raising with your manager because it usually means something in the workload or the process needs to change. Of course, different teams have different expectations, and some roles do involve occasional after hours support.
The important distinction is between an agreed responsibility that you can plan for and a constant pattern of unexpected work that leaves you unable to switch off. Protecting your time isn't about doing less. It's about making sure the person deciding what gets prioritized actually has accurate information to decide with. And all of this, the workload, the push back, the politics feeds into a bigger question we're thinking about early. Where do you actually want this career to go? Your career probably won't go exactly according to the plan you have right now. You might start as a developer and move into cloud.
You might start in testing and end up in automation. You might begin with one programming language and spend most of your career using a completely different one. You might discover you actually enjoy working with data more than building applications or that you like infrastructure more than writing application code. And sometimes the change happens because of a project you never expected to work on. You might get assigned to a cloud migration, start learning how the infrastructure works, and discover that's the part of the job you enjoy most. You don't have to figure out your entire career before you start working.
That's normal. Technology changes, companies change, your own interests change, and your career changes right along with them. The useful thing to build early isn't an attachment to one particular technology. It's a strong foundation. Programming, databases, networking, Git, cloud concepts, debugging, system thinking, and communication. Once those fundamentals are solid, picking up a new tool becomes far easier. Think about it this way. If you understand databases, learning a new database platform becomes much easier because the underlying concepts are familiar. If you understand networking, a new cloud provider's networking services won't feel completely foreign.
You're learning a different implementation of concepts you already understand. A framework can fall out of fashion, a cloud service can get replaced, a programming language can rise or fall in popularity, but the ability to learn quickly and solve problems stays useful no matter what changes around it. This is also why you shouldn't feel pressured to learn every new technology the moment it appears. Pay attention to what's relevant to your role, build depth in the areas you use, and explore new tools when there's a genuine reason to. Understanding a few things well is often more valuable than knowing a little about everything.
And since we just talked about logging your work, it's worth saying plainly, genuine career growth usually isn't the result of politics or self-promotion. It's the compounding effect of consistently delivering, taking ownership of problems beyond just your assigned ticket, and being someone people can rely on. Visibility matters, which is exactly why that habit of logging your own work matters, but visibility only helps you if there's real substance underneath it. Growth that isn't built on that foundation tends to be short-lived. Building that kind of foundation is one thing, making sure anyone actually notices it is another.
Here's something that surprises a lot of first-year developers. Your manager does not remember most of what you did 6 months ago. Not because they don't care, but because they're tracking an entire team, not just you. When appraisal season comes around, they're often reconstructing your year from memory, a few Jira tickets, and whatever you tell them. If you don't tell them, that work quietly disappears from the story. The fix is a habit, not a personality trait. Once a week, write two or three lines for yourself, what you shipped, what problem it actually solved, and anything notable, a teammate you helped unblock, a bug you caught before it reached customers, a process you improved.
It doesn't need to be polished, it just needs to exist somewhere outside your own memory. For example, instead of writing worked on the payment API, record that you fixed a timeout issue that was causing payment requests to fail intermittently. The second version captures the actual impact of your work, and six months later, you'll remember much more clearly what you contributed and why it mattered. This isn't self-promotion in the pushy sense. Your manager is very likely advocating for you in rooms you're not in, deciding on raises, promotions, or new opportunities, often based on incomplete information.
Giving them an accurate, specific record of your impact isn't political maneuvering. It's making sure the person representing you actually has the facts. When appraisal time comes, that running log turns into your self-review almost automatically. Specific, honest, and grounded in things that actually happened, instead of a vague attempt to remember your whole year in one sitting. It can also help you spot patterns in your own development. You might notice that you're taking on more complex tasks, helping teammates more often, or becoming the person people approach for a particular area of the system.
Those patterns can help you identify what you're getting better at and where you want to grow next. Genuine growth in your career tends to come from this same place. Consistent, visible impact over time, not from politics and not from constantly promoting yourself in the moment. The log is just what makes sure that consistency doesn't get forgotten. And that log doesn't have to wait for appraisal season to be useful. There's a much more regular place it belongs, your one-on-ones. At some point, your manager will start scheduling a recurring one-on-ones, usually 15 to 30 minutes, just the two of you.
A lot of juniors treat this as a status update. Here's what I've been working on, and leave most of the value on the table. A one-on-ones is one of the few pieces of time at work that's actually meant to be about you, not about the sprint. Status updates already happen at stand-up. This is the time for things that don't fit into a five-minute team meeting. A blocker you've been sitting on quietly, a piece of feedback you want but haven't been given, a question about where your career could go, or simply flagging that a project's timeline feels off before it becomes a bigger problem. For example, maybe you've been struggling with a particular part of the codebase for two weeks, but you haven't mentioned it because you don't want to look inexperienced.
Your one-on-one is a good place to bring that up. Explain what you've tried and ask for guidance. You don't have to arrive with every problem already solved. Sometimes knowing when to ask for help is part of becoming a better developer. This is also exactly where that work log from earlier becomes useful in the moment, not just at appraisal time. Instead of a vague things are going fine, you can walk in with something concrete. I shipped the discount feature. It's the one the support team mentioned came up a lot. I'd like to try picking up something closer to the payment service next. Is that realistic?
That's a very different conversation than one built entirely on the spot. And pay attention to the feedback you receive. If your manager suggests improving how you communicate progress, for example, don't treat it as a criticism to forget once the meeting ends. Pick one practical thing to work on before your next one-on-one, then follow up on how it went. That's how a short conversation turns into actual progress over time. You don't need an agenda every single week, but it 's worth walking in with at least one real thing, a blocker, a question, or something you want feedback on, rather than treating the meeting as something to get through.
Managers generally want to help, but they can only act on what you actually bring to them. And all of this, the log, the one-on-ones, the honest conversations about workload points toward the same bigger question. What actually makes someone good at this job? After working with developers for a while, you notice something interesting. The person who knows the most syntax isn't necessarily the strongest developer. Someone might know 10 programming languages and still struggle to understand a simple production issue. Meanwhile, another developer might know just one language extremely well, but be excellent at breaking down problems, debugging systems, communicating with the team, and making changes safely.
That's because software engineering is bigger than writing code. You need the technical skills, sure, but you also need judgment. Knowing when to ask for help, when to keep investigating, when not to make a risky change, when a quick fix is genuinely enough, and when a problem actually needs a deeper solution. You build that judgment by working through real problems, not just by watching tutorials or learning new frameworks. When something breaks, take the time to understand why it broke, what caused it, and how you could prevent the same issue from happening again. Over time, those experiences start changing how you approach problems.
You need to communicate clearly, and you need to understand that your code affects other people, not just your own to-do list. There's a related trap worth naming directly. It's possible to complete ticket after ticket for months and still barely understand how the system actually fits together. Finishing tickets keeps you employed. Understanding the system is what makes you genuinely valuable. That means occasionally reading code you weren't assigned to touch, asking why something was built a certain way instead of just how to change it, and noticing how your one piece connects to the rest of the application.
The developers people actually go to for help aren't necessarily the ones who've closed the most tickets. They're the ones who can answer, Wait, how does this whole thing actually work? And you don't have to understand the entire system overnight. Start with the part you're working on, then follow the connections. Where does the data come from? What calls this service? What happens after your code runs? Each answer gives you a slightly bigger picture, and eventually, problems that once seemed confusing start making sense. So, as you progress in your career, don't measure yourself only by how much code you can write.
Measure yourself by the problems you can understand and solve. Understanding the system is only half of it, though. You also have to be able to explain what you understand to people who don't share your technical vocabulary, which is its own skill worth building on purpose. A product manager asks, Can we just add a filter to this page by Friday? And a developer answers with a sentence full of words like schema migration and cache invalidation. Both people walk away from that conversation a little frustrated, and neither one was wrong. Different roles on a software team aren't just doing different tasks.
They're usually optimizing for different things, and talking past each other usually comes from forgetting that. A product manager is mainly thinking about what the business and the customer need and when. A designer is thinking about how it should look and feel and whether it's actually usable. QA is thinking about what could go wrong and whether it 's been checked. None of them are thinking primarily about your database schema, and they shouldn't have to. The habit that closes that gap is translating constraints into outcomes instead of mechanisms. Instead of saying, that requires a schema migration, try something like this.
That's possible, but it touches how we store existing data, so it'll take a bit longer and needs to go out carefully, probably Tuesday instead of Friday. That gives a non-technical teammate something they can actually act on, a timeline and a reason, not a term they have to look up. This works in both directions. When a request seems vague, like make it faster or make it feel more modern, it helps to resist answering it purely technically right away. Ask what specific moment prompted the request. Make it faster often means one particular screen felt slow to one particular person on one particular day, not that the whole system needs a redesign.
Finding that specific moment usually turns a vague ask into a concrete solvable problem. Q&A deserves that same respect in the other direction. You already know not to take a rejected ticket personally. The missing half of that habit is what to do next. Ask for the exact steps that reproduce what they saw. A bug report with a vague recollection on your side and precise steps on theirs isn't a disagreement to win. It's missing information to go find. None of this means hiding technical reality or pretending constraints don't exist. It means remembering that the person across from you is optimizing for something just as real as your technical concern.
And the fastest way through a disagreement is usually translating your constraint into their terms, not insisting they learn yours first. Get comfortable with that kind of translation and a lot of the friction that makes a first job feel exhausting quietly disappears. You ask your manager for something small, a paid tool license say, something that costs less than a dinner out. Two weeks later, you still don't have an answer. It's tempting to assume the company is just slow or doesn't care. Usually that's not it. Your request is standing in a line you can't see and it helps to know who else is in that line.
Most engineering teams run two separate ladders at once and the confusing part is that both of them use the word senior somewhere. One ladder is for people who keep writing code and solving technical problems directly, often called the individual contributor track or IC for short. It usually runs from junior to mid-level to senior. At some companies, it continues into staff or principal engineer. Those are people who are still hands-on, but whose decisions now shape how multiple teams build things, not just their own code. The other ladder is for people who manage people. That one usually runs from engineering manager to director to VP of engineering and sometimes at the very top a CTO, the most senior engineering role in the company.
Here's the distinction that actually matters day-to-day. An engineering manager's job is to support their team. That means running one-on-ones, giving feedback, deciding priorities, and clearing obstacles. They're usually not writing much production code themselves anymore. A senior or staff engineer on the other hand might outrank a lot of people in technical judgment while having nobody reporting to them at all. Seniority and being someone's boss are not the same thing, and mixing them up is an easy mistake to make in your first few months. So where did your two-week request actually go? In a lot of companies, something like a budget item, even a small one, follows the management ladder, not the technical one.
Your manager might be able to approve it alone. If not, it goes up to their manager, a director, who's balancing it against requests from several teams, not just yours. If it's bigger, it might need a VP's sign-off, someone thinking about the budget for an entire part of the company, not a single request. Each step isn't necessarily someone being difficult. It's someone who has to weigh your one request against everyone else's, and that takes longer than you'd expect from the outside. And where does the CEO fit into all this? At a small startup, you might actually talk to them directly. At a larger company, the CEO is usually several layers removed from your day-to-day work entirely, focused on the company as a whole rather than any single team's decisions.
The product side of the house runs a similar ladder in parallel. Product managers, then a director of product, then a VP, sometimes up to a chief product officer. The engineering and product ladders meet near the top to decide what the company builds and in what order. None of this means you need to learn everyone's name or title. In practice, almost everything you do will run through your direct manager and maybe a tech lead or a senior engineer you work closely with. The rest of the chain mostly matters for reason. It explains the timing. And it explains the no you sometimes get for reasons that have nothing to do with you.
A slow approval is rarely about you personally. It's usually just a request waiting its turn in a line with a lot of other requests in it. So the next time something you asked for takes longer than it seems like it should, remember this. It's probably not stuck because it's a bad idea. It's stuck because it's standing in a line. And now you know roughly how long that line is. Understanding that chain helps you make sense of decisions above you. It's a separate question who you can actually turn to for advice. You have a question that doesn't belong in a one-to-one with your manager. Something like, should I stay on this team or should I try to move to a different one?
Your manager is the wrong person to ask that to, at least at first. They're the person evaluating you. That changes what you can safely say to them. This is where a mentor comes in. A mentor is different from a manager in one important way. A mentor doesn't decide your raise. They don't write your performance review. They're not involved in whether you get promoted. That's exactly what makes them useful. You can ask them things you wouldn't ask your manager and they can give you an honest answer without it affecting your career. Some companies assign you a mentor on day one. Most don't. If nobody hands you one, you're allowed to go find one yourself.
Here's how people actually do it. Look for someone whose day-to-day work looks like where you'd like to be in a couple of years. That person doesn't have to be the most senior engineer in the building. It just has to be someone a few steps ahead of you doing something you find genuinely interesting. Now the part that feels awkward. You do not walk up to them and ask, will you be my mentor? That question puts a lot of weight on one moment and most people freeze up and say no, even if they'd have said yes to something smaller. Ask a small thing instead. Something like, I've got a couple of questions about how you code review.
Could I grab 15 minutes sometime? That's an easy yes. And if the conversation goes well, you ask again next month. A few habits make this sustainable instead of a burden on them. Come with a specific question, not just can we chat. Keep it short and end on time even if they offer to go longer. And actually use what they tell you. Nothing kills a mentor relationship faster than asking the same question twice because you didn't act on the answer the first time. You don't need a title for any of this. You just need one person, a little further down the road than you, willing to answer a question every few weeks.
That's the whole relationship and it's worth more than it sounds like at first. Let's finish with the most important thing I want you to take away from this course. Your first IT job can feel overwhelming. There will be tools you've never used. There will be meetings full of terminology you don't recognize. Code bases will look enormous at first and tickets will sometimes make no sense until you actually dig in. There will be days you feel like everyone else already knows what they're doing and you don't. That's normal. Don't expect yourself to become an expert in your first few weeks. And remember, the people around you who seem to know everything were beginners once too.
They've had their own confusing days, broken things they didn't mean to break, and spent hours trying to understand problems that seem obvious to them now. You're seeing their experience today, not all the steps it took to get there. Your goal is simply to keep building context. Then gradually take on more responsibility. After a few months, things that felt complicated will start looking familiar. You'll recognize the tools. You'll understand the architecture. You'll know exactly where to look when something breaks and exactly who to ask when you're stuck. Don't worry about learning everything at once either.
Focus on the task in front of you. Understand what you 're doing and why and learn something from each experience. You don't need to know every answer. You need to get a little better at finding the answers. And some day a new developer will ask you a question you once had yourself. That's when you'll realize how much you've actually learned. If this course has helped you understand a little more about how IT works and feel more confident about getting started, then it's achieved what I hoped it would. It took almost a month to research, write, and edit this course. If you found it useful, please leave a comment and tell me which part you liked most.
And if you'd like to support the channel, please subscribe. It really helps. Thanks for watching and best of luck on your journey into tech.