Deployment module
Getting a Website Online
Understand deployment as a complete publishing system: files, hosting, DNS, domains, testing, troubleshooting, and future updates.
Deployment Is a Publishing System
A website is not truly finished when it works on your computer. Deployment is the publishing system that prepares the files, puts them on a host, connects the address, tests the live result and makes future updates safer.
The button you press matters less than understanding which part of the system that button changes.
- Where are the website files?
- How will future updates reach the live website?
- What evidence would prove the site works for someone else?
After this general module, Black Swan Bistro Part 5 gives you a project-specific application of the same workflow.
The Publishing Flow
Deployment is the part of web work where a private project becomes a public service. That sounds grand, but the practical idea is simple: the files must be prepared, placed somewhere a web server can serve them, connected to a name people can use, and checked after real browsers request them from the internet.
Local project
-> Production-ready files
-> Hosting server
-> DNS
-> Domain name
-> Visitor's browserEach step answers a different question. Your editor creates the files. The build or preparation step makes them ready for visitors. Hosting stores and serves them. DNS points a readable domain to the right service. The browser requests the files and reveals whether the system actually works.
A beginner mistake is treating deployment as an upload event. Upload is only one possible transport method. Deployment also includes deciding what should be uploaded, confirming the server is looking in the right folder, checking whether the domain points to that server, enabling HTTPS, and knowing how the next change will be published without guessing.
Five Deployment Questions
If a deployment feels confusing, return to these questions. They turn a vague problem into a system you can inspect.
- Where are the website files?
- How do the files reach the server?
- How does the domain point to the hosting service?
- How does the browser find and request the files?
- How are future updates published safely?
Those questions apply whether you use a traditional hosting control panel, SFTP, GitHub Pages, Netlify, Vercel, Cloudflare Pages or a more advanced application platform. The labels change. The system thinking stays useful.
Learning Outcomes and Prerequisites
Allow about 160-210 minutes for the full module. You should already be comfortable editing HTML and CSS, testing a page in a browser, and using basic Git if you choose a Git-connected path.
- Explain deployment as a publishing system, not a single upload action.
- Compare hosting models and choose a sensible path for a project.
- Use traditional hosting concepts such as public web roots, File Manager, SFTP and control panels.
- Build and deploy a Vite project using production output.
- Connect domain, DNS, HTTPS and hosting decisions without inventing record values.
- Troubleshoot live deployment problems using evidence.
- Use a repeatable improvement workflow and checklist.
The module deliberately covers both traditional hosting and modern static hosting. Students still meet cPanel-style accounts, public web roots and SFTP in real client work, while Vite projects usually fit better with build-aware platforms. You do not need to love every workflow. You do need to recognise what problem each workflow solves.
Helpful prerequisites: Git Basics, Working with Vite, and Test and Validate Your Site .
Overview Knowledge Check
Before starting Lesson 1, check the system model.
- Why is deployment more than uploading files?
- Which part of the system stores and serves the website files?
- What should you do when provider dashboards change?
Check Your Answers
- Because the files must be prepared, hosted, connected through DNS and a domain, tested live, and updated safely later.
- The hosting server or hosting platform.
- Focus on the purpose of the setting, read current provider documentation, and verify the live result.
How confident are you with this concept?
Still confused | Getting there | Got it | Could explain it to a friend
The Ten-Lesson Sequence
Deployment Is Publishing, Not Just Uploading
Learn what deployment means, why local success is not live evidence, and how browsers, servers, domains, DNS, and files work together.
15-20 minLesson 2Understanding Hosting
Compare shared hosting, static hosting, cloud hosting, VPS, dedicated servers, serverless hosting, and managed application hosting in plain English.
20-25 minLesson 3Choosing a Hosting Path
Choose between traditional shared hosting, manual static hosting, and Git-connected deployment using realistic student and business scenarios.
20-25 minLesson 4Traditional Shared Hosting and Control Panels
Understand shared hosting accounts, public web roots, control panels, account ownership, support boundaries, backups, and provider comparisons.
25-30 minLesson 5Uploading a Plain HTML, CSS and JavaScript Website
Publish a plain static website with a hosting File Manager or SFTP, check folder nesting, and test the live URL.
25-30 minLesson 6Building and Deploying a Vite Website
Understand Vite source files, production builds, dist output, build commands, publish directories, environment variables, and routing concerns.
25-30 minLesson 7Domains, DNS, HTTPS and Going Live
Learn how registrars, DNS providers, hosting providers, SSL certificates, apex domains, www, redirects, and DNS propagation fit together.
20-25 minLesson 8Testing and Troubleshooting a Live Website
Diagnose homepage, CSS, image, 404, white screen, caching, build, DNS, and routing problems using evidence instead of random changes.
25-30 minLesson 9Continuous Improvement and Deployment Workflows
Use manual and Git-based deployment workflows to plan, build, test, deploy, verify, monitor, improve, and repeat.
20-25 minLesson 10Deployment Lab and Final Checklist
Deploy the same tiny site through one or more workflows, compare the experience, use the deployment checklist, and apply the process to Black Swan Bistro.
25-30 minChecklist and Project Application
Download the GraphiteEdge Deployment Checklist
A practical pre-launch, deployment and post-launch checklist for static and Vite websites. The final lesson also keeps a lightweight printable Markdown checklist for in-lesson use.
Ready to Start the Pathway
Key Takeaways:
- Deployment is a publishing workflow, not just a button.
- The live URL is where deployment evidence is gathered.
- The right hosting path depends on files, update workflow, support needs and ownership.
- Troubleshooting starts with the first meaningful error.
Learning Objectives Review:
Look back at what you set out to learn. Can you now:
- Understand deployment as a complete publishing system: files, hosting, DNS, domains, testing, troubleshooting, and future updates. Check!
If you can name which part of the system you are changing, test the live result and record the outcome, deployment is becoming a repeatable workflow.
Think & Reflect:
Deployment evidence
- What would prove this site works for someone else?
Next action
- What should be recorded so this deployment can be repeated later?
Looking Ahead:
Next: continue with Deployment Is Publishing, Not Just Uploading.
Recommended Next Steps
Continue Learning
Ready to move forward? Continue with the next tutorial in this series:
Deployment Is Publishing, Not Just UploadingRelated Topics
Explore these related tutorials to expand your knowledge: