What Junior Web Developers Need to Know About DevOps

How to support the show

Patreon

Prices subject to change and are listed in USD

• Support the show from as little as ~$1/month
• Get a shoutout at the end of the episode (while supplies last) for just ~$3/month
• Help support the HTML All The Things Podcast: Click Here

Scrimba Discount - Coding Courses!

Learn to code using Scrimba with their interactive follow-along code editor.

Join their exclusive discord communities and network to find your first job!

Use our affiliate link for a 20% discount!!

• Click the link to take you to the Scrimba site
• A pop-up should appear on your screen with the discount amount and instructions on how to claim it
• Discount is for new accounts only

We receive a monetary kickback if you use our affiliate link and make a purchase.

Show Notes

1. Why DevOps Matters (Even if You're Not "Doing DevOps")

• The blurred lines between dev and ops today
• How DevOps practices impact your day-to-day as a web dev
• Being a better teammate by understanding where your code goes after you push it
• Prevent yourself from taking down production
• Troubleshoot issues faster
  💡 Example: You're working on a new login page. Once you merge your code, it automatically gets deployed to staging via GitHub Actions. Knowing that helps you test it right away and catch bugs early—without waiting on someone else.

2. Change Management with Git

• Git isn't just version control—it's your safety net
• Branching strategies (feature branches, main/prod, hotfixes)
• How merges, PR reviews, and rebasing relate to CI/CD
• Rolling back via Git (git revert vs git reset)
• Best way to learn Git is to use it, especially when doing group projects in school or with friends
• Examples:
  • 💡 Example: You accidentally push a bug to production. Instead of panicking, you use git revert to roll back just the last change and trigger a redeploy—crisis averted.
  • 💡 Example: You're working on a big feature branch. To stay up to date, you regularly rebase onto main before opening your pull request to avoid messy merge conflicts.

3. Interfacing with DevOps Systems

• You don’t need to build the pipeline—but you should know how to use it
• Triggering builds (e.g., Vercel auto-deploy, manual deploys in Jenkins or Netlify)
• Checking build logs for errors and understanding common failure causes
• Reverting a bad deploy—what to do when your code breaks production
• Examples:
  • 💡 Example: You push a CSS change and suddenly Vercel’s deploy fails. You check the logs, realize you used an invalid Tailwind class, fix it locally, and push again—build passes.
  • 💡 Example: Your Jenkins pipeline fails because of a broken test. You learn to go into the Jenkins dashboard, read the error, and rerun just that one stage instead of the entire pipeline.

4. Popular Tools You’ll Encounter

• Vercel/Netlify: Great for frontend/serverless apps; auto-builds on push, instant rollbacks
• GitHub Actions: Common for CI/CD in open source and startups; integrated into GitHub
• Jenkins: More customizable, often found in legacy or enterprise setups
• CircleCI / Travis CI: Other common CI systems—know how to read the logs, rerun jobs

5. Monitoring and Awareness

• Watching logs and alerts for production issues
• How to report and escalate incidents properly
• Recognizing patterns: when a deploy breaks something, how do you react?
• Examples:
  • 💡 Example: You notice the production app feels slow. You check the logs on Vercel and see a specific API route is timing out—then you alert the team and drop a message in Slack with the relevant error trace.
  • 💡 Example: A teammate pings you about a broken UI on staging. You check your last deploy and realize a CSS file didn’t build properly—you fix it, redeploy, and update the ticket.

6. Good Habits to Start Early

• Writing commit messages that matter
  
  • 💡 Example: Instead of fix stuff, your commit message is fix: correct layout on profile page in Safari. Now your team understands exactly what changed and why.
• Testing before you push (local + automated tests)
  
  • Example: You always run npm run test locally before pushing, so your CI pipeline doesn’t waste time catching things you could have found in seconds.
• Keeping your teammates informed in Slack or your project board
• Understanding environment-specific issues (dev vs staging vs prod)
  
  • 💡 Example: You test a feature in staging, but it works fine locally—turns out the API URL was hardcoded for dev. You learn to use environment variables properly going forward.

Takeaways for Juniors:

• You don’t need to be a DevOps expert—but knowing how to work with DevOps will make you 10x more effective.
• The best junior devs are curious: ask how things are wired up, shadow a senior on a deploy, or poke around a Jenkinsfile.
• Don’t be afraid of failure—mistakes in DevOps are often the best learning opportunities (especially if you know how to revert them!).