Two responsibilities behind one working application
Imagine a small business accepting enquiries through a website. Cloud engineering asks where the application runs, where information is stored, which identities can access it and what happens if a component stops working. DevOps asks how a reviewed change reaches that environment reliably and how the team learns from the result.
Buying a cloud account does not answer those questions. A deployment that works once on one person’s laptop is also different from a repeatable release. In an engineering team, infrastructure changes, application changes and operational feedback need to fit together. Documentation lets another person understand the system rather than depend on its original author.
Learn to explain the system before adding more services
Start with files, processes, Linux commands, IP networking and the difference between an application and its dependencies. Trace a request from a user to the running service. Identify configuration, storage and permissions. If those ideas are unfamiliar, a foundation route is a sensible conversation before a specialist plan.
TWA’s existing learning direction names AWS, Azure and Google Cloud concepts, Git, containers, CI/CD, infrastructure as code and monitoring concepts. These are areas to discuss, not a promise to cover every provider or tool in one plan. Provider documentation is useful for checking what a service actually manages and what remains your responsibility.
Open the new shop. Keep orders moving.
Amaka’s online shop is taking orders. A new version is ready, but nobody has tried placing an order on it yet. A broken update could stop customers buying.
Your role: You are helping the team launch it. Try the update away from customers, fix what you find, then decide when to open it.
What you’ll learn: Learn why an update needs a working check before customers use it.
No account needed. Nothing is sent or saved. You can restart at any point.
Read the full guided story without the interactive controls
You can follow the same lesson here without JavaScript.
Try an order before changing the shop
The current shop works. Choose whether to try a practice order on the update or put customers on it immediately.
What happens and why: A practice order fails: the update cannot reach stored order information. Trying it separately keeps the working shop available. Launching immediately exposes customers to the failure.
Find what the update is missing
Orders need a connection to the shop’s stored information. Keep customers on the working shop while you connect the update.
What happens and why: Connect the update to its order store. In a real application this might mean correcting a database connection setting. Changing colours would not repair that connection.
Check the fix before trusting it
You changed the update. Try the practice order again to see whether the connection now works.
What happens and why: The practice order now succeeds. A readiness check asks whether a candidate can perform a necessary task. It does not prove that every part of the application is perfect.
Open the checked update
The working shop is still serving customers. The updated shop has passed the practice order. You can now switch which version they reach.
What happens and why: Customers are directed to the checked update. This is a deployment: making an application version available. Keep monitoring it and retain a way to return to the previous version, called rollback.
Takeaway: An update can be prepared successfully and still fail to take orders. Check a necessary task, keep the working version available, and switch customers only after the check passes.
Where this is useful: Useful when releasing a website, changing a business application or checking whether an update is safe to open.
A fictional educational example, not a confirmed TWA assignment, assessment or learner outcome. Simplified to explore one idea; real situations need context and authorised procedures.
Optional deeper exploration: open the original technical workspace
Want to explore the technical model?
The guided story above introduces the idea. This original workspace lets you try actions in different orders. It has its own reset and does not inherit your story choices.
- Deployment
- Making an application version available to its users.
- Readiness check
- A check that an update can do a necessary task before people are directed to it.
- Traffic
- Requests from people using the shop.
- Database URL
- A connection setting that tells the application how to reach its stored information.
- Rollback
- Directing users back to a previous working version.
Ship safely. Recover deliberately.
Learning objective: Separate a successful build from a healthy deployment.
A fictional shop is serving version 1. Version 2 builds successfully, but its database URL is missing.
Evidence desk
- Build
- Version 2 compiled; unit checks passed
- Readiness probe
- GET /ready → 503; DATABASE_URL missing
- Current traffic
- Version 1 remains healthy
Your workspace
Worked explanation & takeaway — available without JavaScript
Build success does not prove readiness. Inspect the probe, configure the missing setting, then test version 2 before routing traffic. A failed release should leave version 1 serving. Rollback is a recovery option, not a substitute for understanding the failure.
Fictional educational model. No live system, personal assessment or confirmed TWA assignment. All actions run locally in your browser.
Follow a change into the cloud
This conceptual release path separates changing software from operating infrastructure.
- Commit
A proposed version is recorded and reviewed.
- Check
Automated checks produce results that someone can inspect.
- Deploy
An approved version and its configuration reach the target environment.
- Observe
Service signals inform the next investigation or change.
Hold the release. Inspect the failing check and decide whether the code, test or environment needs correction.
Read both scenarios and explanations
A check fails
Hold the release. Inspect the failing check and decide whether the code, test or environment needs correction.
Errors rise after release
Compare the change and service signals. Consider an approved rollback while investigating; a successful deployment command does not prove the service is healthy.
An educational illustration using fictional situations. It is not a confirmed TWA assignment, live system, assessment or promise of a particular tool.
From deploying a change to operating it
For a fictional enquiry app, write down the configuration required to run it. Keep credentials outside the code, give each role only the access it needs and decide what successful startup looks like. A delivery workflow can check a proposed change, create an identifiable version and send it to a test environment before a production decision.
A failed check should lead to investigation, not an automatic release. After deployment, useful questions include whether requests succeed, whether an error rate changed and whether a previous version can be restored. Cloud design also involves trade-offs between reliability, security, performance and cost. More components are not automatically a better design.
An application handover pack
Plan a small fictional enquiry service and a reviewed route from source code to a test deployment. No paid cloud account or live deployment is required for this illustration.
What you could document
- An architecture diagram showing application, storage and access boundaries
- A configuration checklist without real secrets
- A release checklist with a failed-check decision and rollback note
- An operations handover describing signals and first diagnostic steps
What makes the explanation useful?
A reviewer should be able to trace a request and a release, identify an owner for each component and understand how a failure would be investigated. A diagram with unexplained arrows is not enough.
The learning plan determines actual activities and assessment. These deliverables are examples, not contractual curriculum outcomes.
Directions to deepen after the foundations
Cloud support can emphasise diagnosis and explaining configurations; cloud engineering can deepen architecture and automation; DevOps or platform work can focus on delivery systems and how teams use them. These directions overlap, but they are not interchangeable job titles or guaranteed progression steps.
Before choosing depth, try describing one application clearly: its dependencies, access rules, release process and failure signals. That explanation is more useful for a readiness discussion than a list of product names. Learners in Enugu or elsewhere can discuss a plan around their current infrastructure and software experience.