Deploying Your First Production App: Why Most Bootcamp Grads Skip This (And Why McTaba Doesn't)

Here is a scene that plays out constantly. A developer finishes a bootcamp or an online course. They have built a React app, maybe a full-stack project with a Node.js backend and a database. It works on their machine. They are proud of it. Then a hiring manager or a potential client says: "Can you send me the link?"

Silence.

The project lives on localhost:3000. It has never seen the internet. The developer knows it works, but they cannot prove it to anyone who does not have access to their laptop.

This is the deployment gap. It sits between "I can build things" and "I can ship things," and it is wider than most people realise. Bootcamps spend weeks teaching React components, database queries, and API design. Then deployment gets 30 minutes on the last day, if it is covered at all. Online courses are worse. Most end at the point where the app runs locally, with a vague note to "deploy to Heroku" (which no longer has a free tier) or "try Vercel" (with no explanation of what happens when your app needs environment variables or a backend).

The result: thousands of developers who can build genuinely useful applications but have zero deployed projects in their portfolios. Their GitHub repos have code, but no live URLs. Their resumes list technologies, but no products anyone can visit.

We see this pattern repeatedly at McTaba. Learners arrive having completed other courses, sometimes two or three, and not a single project they built is accessible on the internet. That is not a knowledge problem. It is a curriculum gap.

Your portfolio only counts if employers can visit the URL.

That statement sounds obvious, but the implications are severe. Consider what happens when a Nairobi hiring manager reviews two junior developer candidates. Both list "React, Node.js, PostgreSQL" on their resumes. Candidate A has three GitHub repos with README files. Candidate B has three GitHub repos with README files and three live URLs where the hiring manager can click around, test features, and see the projects running in production.

Candidate B wins every time. Not because their code is necessarily better, but because they removed all friction from the evaluation process. The hiring manager did not have to clone a repo, install dependencies, set up a database, and run npm start. They just clicked a link.

Beyond job hunting, deployment teaches you things that local development never will:

• Environment variables. Your database password cannot be hardcoded in a file that gets pushed to GitHub. You learn this lesson the hard way or the right way.
• CORS and networking. Your frontend and backend are suddenly on different domains. Requests that worked on localhost start failing. Understanding why forces you to actually learn how HTTP works.
• Build processes. Your dev server does a lot of work behind the scenes. When you deploy, you discover that your production build handles things differently. Missing assets, broken paths, and environment-specific bugs all surface here.
• Monitoring and debugging in production. When something breaks and you cannot open Chrome DevTools on the user's browser, you need logs, error tracking, and a systematic approach to diagnosing problems remotely.

These are skills that separate a developer who builds projects from a developer who ships products. Every professional development role requires them. Learning deployment early saves you from a painful scramble later.

Price: KES 4,999
Format: Self-paced, online
Link: academy.mctaba.com/courses/deployment-going-live

The course is structured around taking a real project from your local machine to a production URL. Not in theory. You will actually deploy something and see it live by the end. Here is what it walks you through:

Platform-based deployment

• Vercel: Best for frontend apps and static sites. You will deploy a React or Next.js project, configure custom domains, and understand how Vercel's build pipeline works.
• Railway: Best for full-stack apps that need a backend and a database. You will deploy a Node.js API with a PostgreSQL database and learn how Railway handles services, variables, and scaling.
• VPS deployment: For when you need full control. You will set up a basic server, install dependencies, configure Nginx as a reverse proxy, and manage your app with PM2 or a similar process manager.

The fundamentals that apply everywhere

• Environment variables: How to manage secrets, API keys, and configuration across development, staging, and production environments without leaking sensitive data.
• DNS and domains: How to buy a domain, point it at your hosting provider, and understand what A records, CNAME records, and nameservers actually do.
• SSL/HTTPS: Why your site needs HTTPS, how certificates work, and how to set them up (spoiler: most modern platforms handle this automatically, but you should understand what is happening).
• CI/CD basics: Setting up automatic deployments so that pushing to your main branch triggers a new build and deploy. No more manual uploads.
• Monitoring: Basic health checks, logging, and knowing when your app goes down before your users tell you.

Each section includes the specific commands, configuration files, and screenshots you need. This is not a theoretical overview of cloud computing. It is a practical, step-by-step process for getting your projects live.

By the time you finish the course, you should have at least two projects live on the internet with real URLs:

1. A frontend application on Vercel with a custom domain and HTTPS. This could be your portfolio site, a React project from a previous course, or any frontend app you have built. The point is that it is live, fast, and accessible to anyone with the link.
2. A full-stack application on Railway (or a VPS) with a backend API, a database, and environment variables properly configured. This proves you can deploy more than static files. You can ship a real application with a server and persistent data.

These are not throwaway exercises. They are projects you add directly to your portfolio. When you update your resume or LinkedIn profile, you include the live URLs. When a hiring manager asks what you have built, you send them a link that loads instantly in their browser.

If you already have projects from other courses or from self-study that are stuck on localhost, this course gives you the skills to deploy those too. Many learners tell us they go back and deploy two or three older projects right after finishing the material, because the process finally makes sense.

You should take this course if:

• You have built web applications (frontend, full-stack, or backend) but none of them are live on the internet.
• You tried deploying once, hit a confusing error (broken build, missing environment variable, CORS failure), and gave up.
• You are about to start applying for developer jobs and your portfolio has zero live URLs.
• You understand what React, Node.js, or similar tools do, but you have no idea what happens between "it works on my machine" and "it works on the internet."
• You are a freelancer who builds sites for clients but relies on someone else to handle hosting and deployment.

You should skip this course if:

• You have already deployed multiple projects to production and are comfortable with the process. This course covers fundamentals, not advanced infrastructure or DevOps.
• You have never built a web application at all. You need something to deploy before deployment skills become useful. Start with our Tech Foundations course or a beginner coding programme first.
• You are looking for advanced topics like Kubernetes, Docker orchestration, or multi-region cloud architecture. This course targets the gap between localhost and your first production deploy, not enterprise infrastructure.

The course assumes you already have:

• A working web application. Frontend-only is fine. Full-stack is better. It does not matter what framework you used. React, Vue, plain HTML/CSS, Express, Django, Flask. The deployment concepts apply across stacks. If you do not have a project ready, build one first. Our portfolio project ideas guide has suggestions.
• Basic Git knowledge. You should know how to commit, push, and pull. If git push origin main means nothing to you, spend an hour with a Git tutorial before starting.
• A GitHub account. Most deployment platforms connect to your GitHub repos directly. You will need one.
• A terminal you are comfortable using. You do not need to be a command-line expert, but you should be able to navigate directories and run commands without panic.

You do not need prior experience with hosting, servers, DNS, or any specific cloud platform. That is exactly what the course teaches.

Deployment & Going Live is one of four self-paced courses on McTaba Academy. Here is where it sits relative to the others:

Before this course: You should have coding skills. If you are a complete beginner, start with Tech Foundations: Before You Code (KES 2,999) to build your foundation, then learn to build applications through the Full-Stack Software & AI Engineering course (KES 120,000) or another coding programme. Then come back here when you have something to deploy.

Alongside this course: If you are building for the Kenyan market, pair Deployment with M-Pesa Integration for Developers (KES 9,999). The combination of M-Pesa payments and production deployment skills is particularly strong for freelancers. You can build a payment-enabled app and actually ship it. Total for both: KES 14,998.

After this course: With deployment skills in hand, every project you build from this point forward should go live. Your portfolio stops being a list of GitHub repos and becomes a collection of working products. That shift changes how employers and clients evaluate you.

If you are in the McTaba Bootcamp (6-month marathon), deployment is already part of the curriculum. This standalone course is designed for self-taught developers and graduates of other programmes who missed deployment in their training.

Deployment anxiety is real. We hear the same worries from learners over and over:

"What if I break something?" You will. Your first deploy will probably fail. Your environment variables will be wrong, or your build will break because of a dependency issue. This is normal. Deployment platforms have rollback features for exactly this reason. Breaking things and fixing them is how you learn. The difference between a junior developer who can deploy and one who cannot is not that the first one never encounters errors. It is that they know how to read the error log and fix the problem.

"I do not understand servers." You do not need to, at least not at first. Platforms like Vercel and Railway abstract away most server management. You push your code, they build and host it. The VPS section of the course does teach basic server concepts, but you can start with managed platforms and learn server administration later as your needs grow.

"It seems expensive to host things." Vercel and Railway both have free tiers that are generous enough for portfolio projects. You can have multiple projects live without paying anything. Custom domains cost around KES 1,000 to 2,000 per year. Hosting your portfolio is not the financial barrier people imagine it to be.

"My code is not good enough to put online." Your code does not need to be perfect. It needs to work. Every professional developer has shipped code they later improved. The act of deploying forces you to clean up the obvious issues (hardcoded secrets, broken routes, missing error handling), and that cleanup process makes you a better developer. Waiting until your code is "ready" is a trap that keeps your portfolio empty indefinitely.