Question 1. Distinguish the Internet from the World Wide Web.
Model answer: The Internet is the global network infrastructure; the Web is a resource and application system that uses Internet protocols, especially HTTP and HTTPS.
CBE NEXUS · UNDERGRADUATE TEXTBOOK SERIES
Information Systems
Comprehensive undergraduate notes, technical diagrams, applied case studies and university assessment.
The World Wide Web is a distributed information space built on networked computers and interoperable standards. A web application is not simply a collection of pages: it is an information system with users, business rules, data, interfaces, security controls, operational processes and measurable outcomes. Organisations use web platforms for commerce, learning, public services, collaboration, customer support and internal workflows. The web's reach makes accessibility, performance, privacy and resilience central design concerns.
The Internet is the global network infrastructure that connects networks using common protocols. The Web is one service that operates over that infrastructure. A browser requests resources from servers using protocols such as HTTP or HTTPS. DNS translates domain names into network addresses, while routing moves packets between networks. A web application may also rely on APIs, databases, identity providers, content delivery networks and external services.
A useful systems view follows a request from a person using a device, through a browser and network, to a web server, application logic, database and external services. Responses travel back to the browser, where HTML, CSS and JavaScript present information and interactions. Each layer introduces dependencies and potential failure points. Architecture diagrams should identify trust boundaries, data flows and responsibilities, not merely list technologies.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Client-server architecture divides responsibilities between clients that request services and servers that provide them. The browser is commonly the client, while web servers and application services process requests. In a thin-client model, much processing occurs on servers; in a rich-client model, more interface and application logic runs in the browser. Most modern systems combine both approaches.
A three-tier architecture separates presentation, application logic and data management. The presentation tier handles interaction; the application tier implements business rules and coordinates services; and the data tier stores and retrieves information. This separation improves maintainability and allows components to scale independently, but introduces network calls, deployment coordination and distributed failure handling.
A monolithic application packages many functions into one deployable unit. A modular monolith maintains clear internal boundaries while deploying together. Microservices divide a system into independently deployable services organised around business capabilities. Microservices can improve independent scaling and team autonomy, but add operational complexity, network latency, service discovery, observability and distributed data consistency challenges. Architecture should fit the organisation's capacity and problem scale.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
HTTP is an application-layer protocol for request-response communication. A request includes a method, target, headers and sometimes a body. A response includes a status code, headers and sometimes a body. Common methods include GET for retrieval, POST for submitting or creating operations, PUT for replacing a resource, PATCH for partial modification and DELETE for removal. Correct method semantics help clients and servers communicate predictably.
Status codes communicate outcomes. The 2xx family indicates success, 3xx redirection, 4xx client-side problems and 5xx server-side failures. For example, 200 means success, 201 indicates creation, 301 is a permanent redirect, 400 indicates a malformed request, 401 concerns authentication, 403 indicates refusal, 404 means not found and 500 indicates an internal server error. Applications should return useful, safe error messages without exposing secrets or stack traces.
HTTPS is HTTP protected by TLS, providing encryption in transit, server authentication and integrity protection. Certificate validation helps a browser establish that it is communicating with the intended service. HTTPS does not make an application automatically secure: authorisation, input validation, secure session handling, patching, logging and safe data storage remain necessary. Sensitive applications should avoid mixed content and insecure redirects.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
The Domain Name System maps human-readable domain names to records such as IP addresses and service destinations. A user entering a domain triggers a resolution process that may involve recursive resolvers and authoritative name servers. Records such as A, AAAA, CNAME, MX and TXT support different services. DNS changes may take time to appear because resolvers cache records according to TTL values.
Web hosting provides infrastructure for delivering web content and application services. Static hosting serves prebuilt files; application hosting runs server-side code; managed platforms abstract infrastructure operations; and cloud infrastructure offers configurable compute, storage and networking. Hosting decisions should consider deployment process, regional latency, availability, data location, security controls, cost and support.
A content delivery network distributes cached content across geographically dispersed edge locations. It can reduce latency and origin load for cacheable resources, provide TLS termination and absorb some traffic spikes. Dynamic or personalised content requires careful cache rules. Incorrect caching can expose one user's private response to another or serve stale information. Cache invalidation and versioned assets should be part of release planning.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
HTML describes the structure and meaning of web content. Elements identify headings, paragraphs, lists, links, images, tables, forms, navigation and other content. Semantic HTML communicates the purpose of a region to browsers, assistive technologies and search engines. A page should have a logical heading hierarchy and meaningful landmarks such as header, nav, main, section, article and footer where appropriate.
An accessible page uses headings to organise content rather than choosing heading levels only for visual size. Links should describe their destination, images should have appropriate alternative text, and tables should use headers to identify data relationships. Buttons perform actions; links navigate. Misusing clickable generic elements can make keyboard and assistive technology interaction confusing.
HTML validation catches malformed nesting, missing attributes and other structural problems. Progressive enhancement begins with meaningful content and core navigation, then adds richer behaviour. A page should remain understandable if a script fails or a network request is delayed. Semantic structure also improves maintainability because developers can understand the purpose of each element.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
CSS controls presentation, including typography, colour, spacing, borders, layout and responsive behaviour. The cascade resolves competing rules using origin, importance, specificity and source order. Reusable classes and design tokens help maintain consistency. Avoid excessive specificity and duplicated declarations because they make later changes difficult to reason about.
Flexbox supports one-dimensional alignment and distribution; CSS Grid supports two-dimensional layouts; and normal document flow provides a robust default. Responsive design adapts to viewport size and interaction context using flexible dimensions, media queries and content-aware breakpoints. Layout should be tested on narrow screens, zoomed text and different input methods.
A responsive interface should preserve task completion rather than merely shrink desktop cards. Navigation, forms, tables and diagrams need deliberate small-screen behaviour. Use adequate contrast, visible focus indicators, readable line lengths and touch targets. Performance is also affected by font loading, image dimensions and unnecessary style complexity.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
JavaScript adds behaviour to web pages. The browser parses HTML, constructs a document object model (DOM), applies styles, performs layout and paints pixels. JavaScript can respond to user events, update the DOM, validate forms, request data and coordinate interface state. The event loop manages tasks and asynchronous callbacks; long-running synchronous work can block interaction and make the page appear frozen.
Variables, functions, objects, arrays, modules, promises and async/await are common language features. Use clear naming, small functions and explicit error handling. Strictly separate trusted code from untrusted input. Avoid inserting untrusted strings as executable HTML. Browser storage and cookies have different security and lifetime properties, so sensitive authentication material should be handled according to established secure session patterns.
Client-side validation improves usability but is not a security boundary. Attackers can bypass browser code and send requests directly. Every important rule must be validated by the server or trusted service. JavaScript should progressively enhance a working interface, expose clear loading and error states, and avoid silently swallowing failures.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Forms collect information through labels, inputs, selects, text areas, buttons and related controls. Each control needs a clear label and appropriate input type. Group related fields with fieldsets and legends where useful. Instructions should explain required formats, why information is needed and how errors will be handled. Error messages should identify the field and describe a corrective action.
Validation can occur in the browser and on the server. Client-side checks catch obvious omissions quickly, while server-side validation enforces authoritative rules. Validate type, length, range, format, allowed values, relationships and business rules. Normalise data carefully and preserve original values where they are legally or operationally significant.
A robust form preserves safe user input when validation fails, identifies errors in text and does not rely on colour alone. Avoid asking for unnecessary personal information. Explain consent and purpose where relevant. For multi-step forms, show progress, allow review and prevent accidental duplicate submissions. Rate-limit sensitive endpoints and protect against automated abuse.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
The DOM represents a document as a tree of nodes that scripts can inspect and modify. Event handling responds to actions such as click, input, submit, keydown and change. Event bubbling allows an event to travel through ancestor elements; delegation can handle events for many similar child elements efficiently. Handlers should be scoped and removed when no longer needed in long-lived interfaces.
Asynchronous requests allow a page to retrieve or submit information without a full navigation. Fetch-style APIs return promises and require handling of network errors, non-success status codes, parsing failures and timeouts. A loading indicator, empty state and retry option make asynchronous behaviour understandable. Abort mechanisms can cancel obsolete requests when users change search terms quickly.
Race conditions occur when responses arrive in a different order from requests. Use request identifiers, cancellation or state checks so an older result does not overwrite a newer one. Prevent duplicate actions while a request is pending, but do not assume a client-side disabled button prevents repeated server requests. Server-side idempotency is important for payments and other consequential operations.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
An application programming interface (API) defines how software components communicate. A web API commonly exposes resources through HTTP endpoints and exchanges JSON. REST is an architectural style based on constraints such as resource identification, stateless interaction and a uniform interface. Many services are described as REST-like even when they do not implement every REST constraint.
Design endpoints around stable resources and clear semantics. Use appropriate methods and status codes, validate request bodies, define response schemas and provide consistent error formats. Pagination, filtering, sorting and versioning should be documented. Authentication identifies a caller; authorisation determines what that caller may do. Never assume that an authenticated user may access every object identifier they can guess.
API documentation should include purpose, parameters, response examples, error cases, authentication, rate limits and version policy. Backward-compatible changes reduce disruption. Breaking changes need a migration plan and communication. Monitor usage and deprecate obsolete versions transparently. Avoid exposing internal database structure as the public contract.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
JSON is a lightweight text format commonly used by browser and server applications. It supports objects, arrays, strings, numbers, booleans and null. XML represents structured data with elements and attributes and can support namespaces and schemas. CSV is often used for tabular exchange but has weaker type and relationship semantics. Select formats according to interoperability and validation requirements.
A schema defines expected fields, types, constraints and relationships. Validation detects missing or unexpected values before processing. Dates, times, currencies and numeric precision require explicit conventions. For example, a timestamp should include a timezone or a clearly defined timezone policy. Locale-specific decimal and date formats should not be assumed to be universal.
Data exchange must consider encoding, character sets, escaping, file size, schema evolution and trust. Treat imported files and API payloads as untrusted. Limit size and nesting depth where appropriate. Avoid parsing unsafe XML configurations that permit external entity resolution. Record source, time, transformation and validation results for important imports.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Server-side code receives requests, authenticates callers, validates input, applies business rules, interacts with data stores and returns responses. Frameworks provide routing, middleware, templating, validation, database access and security features. They accelerate development but do not remove the need to understand HTTP, data integrity and security.
A request pipeline may perform request parsing, correlation-ID assignment, authentication, authorisation, validation, business processing, persistence and response formatting. Middleware order matters. Errors should be handled centrally, logged with useful context and returned with safe public messages. Secrets and personal data should not be written into routine logs.
Framework selection should consider ecosystem maturity, security updates, team expertise, performance, accessibility support, testing, deployment and long-term maintenance. Avoid unnecessary dependencies. Pin and review packages, monitor vulnerabilities and remove unused components. A framework's default configuration is a starting point, not proof that the deployed application is secure.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Separation of concerns places distinct responsibilities in components with clear interfaces. Presentation code should not contain every business rule; data access should not be duplicated across unrelated pages; and authentication should not be reimplemented inconsistently. Layered architecture, modular design and dependency injection can support testability and maintainability.
A controller or route handler should coordinate a request rather than become a large collection of unrelated rules. Domain services express business operations; repositories or data-access components manage persistence; and presentation components render results. The exact pattern varies, but boundaries should make responsibilities and dependencies understandable.
Avoid overengineering. A small application may be better served by a modular monolith than by a network of microservices. Split services when independent deployment, scaling, ownership or isolation provides measurable value. Every new boundary adds operational and failure-handling work. Architecture decisions should be documented with context, alternatives and consequences.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Authentication verifies identity; authorisation evaluates permitted actions. Common authentication approaches include passwords, multi-factor authentication, federated identity and passkeys. Passwords should be stored using an appropriately slow, salted password-hashing algorithm rather than reversible encryption or plain text. Account recovery must be designed as carefully as login.
Sessions maintain continuity between requests. Secure cookies should use appropriate Secure, HttpOnly and SameSite attributes, with suitable expiry and rotation policies. Protect state-changing requests against cross-site request forgery where the session design requires it. Use short-lived access credentials where appropriate and revoke sessions after account compromise or privilege changes.
Authorisation should be checked on every sensitive server-side operation, not merely by hiding interface controls. Apply role-based or attribute-based policies and verify ownership at the object level. Test horizontal privilege escalation, where one user accesses another user's records, and vertical escalation, where a lower-privilege user performs administrative actions.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
The OWASP Top 10 is a widely used awareness reference for important web application security risks. Common issues include broken access control, cryptographic failures, injection, insecure design, security misconfiguration, vulnerable components, authentication failures, integrity failures, logging gaps and server-side request forgery. Risk depends on application context and exposure.
Injection occurs when untrusted input changes the meaning of a command or query. Parameterised database queries separate data from SQL instructions. Cross-site scripting (XSS) occurs when attacker-controlled content executes as script in another user's browser; contextual output encoding and safe templating reduce risk. Cross-site request forgery (CSRF) abuses a browser's authenticated session to trigger unwanted actions.
Security is a lifecycle activity. Threat modelling identifies assets, trust boundaries, attackers, entry points and mitigations. Secure defaults, dependency scanning, code review, automated tests, penetration testing and incident response complement one another. Do not publish secrets in source code or client bundles. Rotate exposed credentials and investigate whether they were used.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Web accessibility enables people with different sensory, motor, cognitive and learning characteristics to use digital services. WCAG principles are commonly summarised as perceivable, operable, understandable and robust. Accessibility is not a decorative enhancement: it affects whether people can obtain education, healthcare, employment, financial and public services.
Provide text alternatives for meaningful images, captions or transcripts for relevant media, keyboard operation, visible focus, sufficient contrast, logical headings, descriptive links and clear form errors. Avoid relying on colour, animation or precise pointer movements as the only means of understanding or operating a page. Support zoom and reflow without loss of content or function.
Automated accessibility tools detect some problems but cannot judge every interaction. Test with keyboard-only navigation, screen readers, zoom, high contrast and users with varied needs. Include accessibility criteria in requirements, design reviews, acceptance tests and procurement. Fixing accessibility early is usually less expensive than retrofitting a finished system.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
User experience includes the perceptions and responses arising from use of a product or service. Usability considers whether intended users can achieve goals effectively, efficiently and satisfactorily in a context. Interaction design structures tasks, feedback, navigation, error recovery and system behaviour. Good design begins with users and their work rather than with a preferred visual style.
Research methods include interviews, contextual observation, surveys, journey mapping, task analysis and usability testing. Personas can summarise research patterns but should not be invented stereotypes. Prototypes make assumptions testable before expensive implementation. A usability test should define tasks, participants, measures and ethical safeguards.
Measure task completion, time on task, error rate, abandonment, satisfaction and accessibility barriers. Do not optimise clicks at the expense of comprehension or safety. Critical operations need confirmation, clear status and recoverable errors. Design for real connectivity, devices, language and literacy contexts.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Testing checks whether software meets requirements and behaves safely under expected and unexpected conditions. Unit tests examine small functions or components; integration tests verify interactions between modules and services; system tests exercise the complete application; and acceptance tests confirm fitness for user needs. Regression tests help detect unintended effects of changes.
Functional testing covers expected behaviour; non-functional testing examines performance, security, accessibility, compatibility, reliability and usability. Boundary tests examine minimum, maximum, empty, malformed and unusually large inputs. Negative tests verify that unauthorised or invalid actions are rejected. Test data should be realistic without unnecessarily exposing personal information.
A good test case identifies preconditions, inputs, actions, expected outcomes and evidence. Automated tests should be repeatable and stable. Flaky tests waste engineering time and weaken trust. Production monitoring complements pre-release testing because real environments contain variable traffic, devices, networks and dependencies.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Web performance affects task completion, user satisfaction, search visibility and operational cost. Important measures include response time, throughput, error rate, page weight, rendering delay and interaction responsiveness. Measure performance from the user's perspective as well as from server metrics. A fast server response does not guarantee a fast page if images and scripts delay rendering.
Optimisation techniques include image compression and responsive formats, browser caching, code splitting, minification, efficient queries, connection reuse, content delivery networks and reducing unnecessary third-party scripts. Lazy loading can defer off-screen resources but should not delay important content. Caching must respect privacy and freshness requirements.
Use realistic network and device profiles. Measure median and tail latency, not only an average. Profile before changing code, identify the bottleneck and compare results after one controlled change. Load testing should model concurrent users, traffic bursts and dependency behaviour. Define capacity limits and graceful degradation when demand exceeds capacity.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Deployment moves a tested software version into an environment where users can access it. Environments commonly include development, test or staging, and production. Configuration should be separated from source code, with secrets supplied through secure environment configuration. Releases should be traceable to commits, build artefacts and approved changes.
Continuous integration automatically builds and tests changes. Continuous delivery keeps software in a deployable state; continuous deployment automatically releases qualifying changes. A pipeline may include dependency checks, static analysis, tests, build, artefact storage, approval, deployment and post-deployment verification. Rollback or roll-forward procedures should be defined.
Use version control to record changes and support collaboration. Small, reviewable commits are easier to understand and revert. Database migrations, environment variables, DNS, caches and external integrations are part of deployment risk. Verify the deployed commit and test critical user journeys after release. A successful build does not prove that the public service works correctly.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Cloud-native design uses automation, managed infrastructure, elastic resources and observable services to support changing demand. Scalability can be vertical, by increasing the capacity of one machine, or horizontal, by adding instances. Stateless application instances are easier to scale because session state is held in a shared service or secure client token rather than local process memory.
Load balancers distribute requests; queues absorb bursts and decouple work; object storage holds files; managed databases provide persistence; and autoscaling adjusts capacity according to demand signals. These components introduce quotas, latency, cost and dependency risks. Design timeouts, retries, circuit breakers and back-pressure to avoid cascading failures.
Resilience means continuing or recovering when components fail. Redundancy, health checks, backups, multi-zone deployment and tested incident procedures contribute to resilience. Do not retry every failure indefinitely: retries can amplify overload. Use bounded retries, jitter and idempotent operations. Cost observability is part of cloud architecture because uncontrolled scaling can create financial harm.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
A progressive web application (PWA) uses web technologies to provide capabilities such as installability, offline experiences and background behaviour where supported. A web app manifest describes presentation and launch details; service workers can intercept requests and manage caches. Browser support and platform rules vary, so capability detection and graceful fallbacks are essential.
Offline design requires decisions about which content is safe and useful to cache, how stale data is identified and what happens when users make changes without connectivity. Sensitive personal or financial information should not be cached casually. Conflicts can occur when offline changes are synchronised after other users have changed the same records.
Mobile web development considers small screens, touch, intermittent connectivity, battery, accessibility and data cost. Responsive design is usually preferable to maintaining separate content systems without a compelling reason. Test on actual devices and realistic networks. An offline indicator should communicate whether the user is viewing cached information or submitting a synchronised change.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
E-commerce applications support product discovery, catalogues, carts, checkout, payment, fulfilment, refunds and customer service. Each step has distinct state transitions and risks. Inventory reservation, payment authorisation and order confirmation must be coordinated so that duplicate requests or delayed notifications do not create inconsistent outcomes.
Payment systems should use trusted payment providers and avoid storing sensitive card data unless the organisation is properly authorised and equipped to do so. Verify provider callbacks, signatures and transaction references. Idempotency keys help prevent duplicate charges when requests are retried. Reconcile provider settlement records with internal orders and refunds.
A public service portal has similar concerns: identity, eligibility, form submission, fees, case tracking, notifications and audit. Design should make service rules understandable and provide accessible alternatives when digital access is unavailable. Protect personal records and ensure staff can resolve exceptions without bypassing controls.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
A content management system (CMS) separates content creation and management from some aspects of presentation and delivery. It may provide roles, editorial workflows, media libraries, templates, version history, search and publishing schedules. Headless CMS designs expose content through APIs to multiple channels, while traditional systems combine content management and page rendering.
Publishing governance defines authors, editors, approvers, update schedules, ownership and withdrawal rules. Content should be accurate, original, accessible and useful. Metadata, structured headings, internal links and descriptive page titles support discovery, but search optimisation must not replace reader value. Empty pages, broken navigation and misleading claims damage trust.
CMS security includes patching, plugin review, administrator protection, backups, least privilege and careful file upload handling. Editorial workflows should prevent accidental publication of drafts or private information. Preserve redirect mappings when URLs change and verify canonical links, sitemaps and structured data after major migrations.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Search engines discover pages through links and sitemaps, fetch accessible resources, interpret content and decide whether to index and rank pages. Clear information architecture, descriptive titles, useful headings, internal links, canonical URLs and accurate structured data help machines interpret content. No metadata guarantees indexing or ranking.
Structured data expresses entities and relationships in machine-readable form using supported vocabularies. It must match visible page content and comply with search-engine policies. Search snippets are selected by search systems and can change. Avoid keyword stuffing, doorway pages, fabricated reviews and schema that describes content users cannot see.
Technical discoverability includes crawlable links, appropriate status codes, mobile usability, page performance and correct robots directives. A sitemap helps discovery but does not guarantee indexing. Monitor indexing and search performance, inspect representative URLs and fix substantive content or technical issues rather than repeatedly resubmitting unchanged pages.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Web analytics can help organisations understand acquisition, navigation, task completion and performance. Collection should be proportionate to a defined purpose. Use privacy notices, appropriate consent or other lawful bases, data minimisation, retention limits and access restrictions. Avoid placing sensitive personal information in URLs, analytics events or error logs.
Cookies, local storage, pixels and server-side analytics have different technical and regulatory implications. Consent requirements vary by jurisdiction and context. Analytics identifiers may still be personal data when they can be linked to an individual. Provide controls that are understandable and respect user choices. Do not infer that a visitor has consented merely because a banner was displayed.
Interpret analytics carefully. A rise in page views may reflect repeated failed navigation rather than success. Pair quantitative metrics with user research and service outcomes. Document event definitions, exclusions, attribution limitations and data quality. Restrict access to raw event data and review third-party processors.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Web development is multidisciplinary. Product owners, analysts, designers, developers, testers, security specialists, content editors, operations teams and users contribute different expertise. Requirements should connect user needs to measurable outcomes and acceptance criteria. Scope, budget, schedule, dependencies and risks must be managed throughout delivery.
Agile methods use iterative planning, feedback and delivery; Scrum defines roles, events and artefacts; Kanban visualises flow and limits work in progress. These methods are not substitutes for governance or technical discipline. Select a process that fits team size, regulatory obligations, uncertainty and stakeholder availability.
A product backlog should prioritise value, risk and dependencies. Definition of done should include tests, accessibility, documentation, security review and deployment readiness as appropriate. Retrospectives should produce specific improvement actions. Stakeholder demonstrations and user acceptance help prevent teams from delivering technically complete but operationally unsuitable features.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
Web technologies continue to evolve through browser standards, edge computing, real-time communication, immersive interfaces, AI-assisted features and new identity approaches. WebAssembly can run compiled code in supported browser environments; WebSockets support bidirectional communication; server-sent events support server-to-client event streams; and edge computing moves selected processing closer to users.
AI-enabled interfaces may support search, summarisation, recommendations and service assistance, but introduce risks of inaccurate output, bias, prompt injection, privacy leakage and over-reliance. Use trusted data boundaries, human review for consequential decisions, clear disclosure and evaluation. An AI feature should have a defined purpose, measurable quality and a safe fallback.
Professional developers maintain competence, respect intellectual property, disclose conflicts, protect users and document limitations. Standards and platform capabilities change, so consult current documentation and test across supported browsers. Choose technologies for a demonstrated need rather than novelty. Maintainability, accessibility, security and user benefit remain durable engineering priorities.
In a professional project, translate these principles into acceptance criteria and test evidence. Identify the user group, data handled, trust boundaries, failure modes and operational owner. Record assumptions and trade-offs so another developer can understand why the design was selected. Review the result with users and test the complete journey, including errors and recovery rather than only the ideal path.
A university wants applicants to discover programmes, create accounts, submit applications, upload supporting documents, pay an application fee and track decisions. Admissions officers need queues, verification tasks, decision controls and audit history. The portal must support applicants on mobile devices and unreliable connections.
Model the user journeys and state transitions: draft, submitted, under review, additional information requested, accepted, rejected or withdrawn. Define which roles may perform each transition. The browser validates obvious omissions, while the server verifies eligibility, file type and size, payment status and ownership. Store documents in protected object storage and keep references and access policy in the application database.
Test duplicate submissions, repeated payment notifications, expired sessions, malicious uploads, unauthorised record access, network interruption and concurrent officer decisions. Use accessible labels and error summaries. Measure completion, abandonment, processing time and support requests. Provide an alternative support route for applicants who cannot complete the digital process.
Prepare a context diagram, user stories, data-flow diagram, role matrix and test plan for this case. Prioritise risks according to likelihood and impact. Define measurable service outcomes and identify how the team will monitor them after release. Include accessibility, privacy and security in the acceptance criteria rather than treating them as final-stage checks.
A retailer's website supports product search, stock checks, cart, checkout, payment, order tracking and refunds. A customer may click Pay twice, lose connectivity after submitting or receive a delayed provider notification. Inventory may be purchased by multiple customers at the same time.
Create an order state machine and separate payment authorisation from settlement and fulfilment. Use a unique idempotency key for each checkout attempt and verify signed provider notifications. Reconcile uncertain payment outcomes before asking the customer to retry. Reserve inventory with concurrency controls and release expired reservations according to a documented policy.
Test a successful payment, declined payment, timeout, duplicate callback, refund, partial fulfilment and stock conflict. Ensure the interface does not claim success until authoritative confirmation is available. Log transaction references without exposing sensitive payment data. Provide a clear customer support and dispute process.
Prepare a context diagram, user stories, data-flow diagram, role matrix and test plan for this case. Prioritise risks according to likelihood and impact. Define measurable service outcomes and identify how the team will monitor them after release. Include accessibility, privacy and security in the acceptance criteria rather than treating them as final-stage checks.
A health service portal allows patients to find facilities, request appointments and receive reminders. Clinical staff need schedules and patient context, while administrators manage capacity. The service handles sensitive personal information and must remain available during busy periods.
Use role-based access and verify patient-record ownership on every request. Separate appointment scheduling data from clinical notes where appropriate. Encrypt communications, restrict logs and protect backups. Design for assistive technology and low-bandwidth devices. Provide an emergency and non-digital route for urgent or inaccessible services.
Assess privacy impact, appointment collision, cancellation, no-show, notification failure and unauthorised disclosure. Monitor availability and response times. Ensure reminders reveal only necessary information. Define retention, access review, incident response and recovery objectives with the responsible health institution.
Prepare a context diagram, user stories, data-flow diagram, role matrix and test plan for this case. Prioritise risks according to likelihood and impact. Define measurable service outcomes and identify how the team will monitor them after release. Include accessibility, privacy and security in the acceptance criteria rather than treating them as final-stage checks.
Answer in structured paragraphs, use diagrams where relevant and explain the reasoning behind technical choices. Model answers indicate core marking points.
Model answer: The Internet is the global network infrastructure; the Web is a resource and application system that uses Internet protocols, especially HTTP and HTTPS.
Model answer: Clients request services and servers process requests and return responses; the browser commonly acts as client and web servers host application services.
Model answer: Presentation manages interaction, application tier implements business rules and data tier stores information.
Model answer: A monolith deploys an application as one unit; microservices divide capabilities into independently deployable services with additional distributed-system complexity.
Model answer: An application-layer request-response protocol used to transfer web resources and interact with web services.
Model answer: TLS protects data in transit through encryption, integrity and server authentication, but does not replace application security.
Model answer: DNS translates domain names into records such as IP addresses and service destinations through recursive and authoritative resolution.
Model answer: Examples include header, nav, main, article, section and footer; they communicate document structure and purpose.
Model answer: HTML defines content structure and meaning; CSS controls visual presentation and layout.
Model answer: An approach that adapts layout and interaction to different viewport sizes, devices and user contexts.
Model answer: The Document Object Model represents a web document as a tree of nodes that scripts can inspect and update.
Model answer: Users can bypass browser code and send requests directly, so authoritative validation must also occur on the server.
Model answer: Authentication verifies identity; authorisation decides which actions and resources that identity may access.
Model answer: An API that uses resource-oriented identifiers and a uniform interface, commonly HTTP methods and representations, with stateless interactions.
Model answer: 2xx success, 3xx redirection, 4xx client error and 5xx server error.
Model answer: Injection occurs when input changes a query's command structure; parameterised queries and safe data handling prevent this class of attack.
Model answer: XSS is execution of attacker-controlled script in another user's browser; contextual output encoding and safe templating reduce the risk.
Model answer: HttpOnly prevents ordinary client-side scripts from reading the cookie; Secure restricts transmission to secure connections.
Model answer: Perceivable, operable, understandable and robust.
Model answer: Unit tests check small components in isolation; integration tests check interactions between components or services.
Model answer: A distributed network of edge locations that caches and delivers content closer to users, reducing latency and origin load.
Model answer: Continuous integration builds and tests changes; continuous delivery keeps releases deployable, while continuous deployment automatically releases qualifying changes.
Model answer: A web application using web capabilities such as installability and service workers to provide app-like experiences where supported.
Model answer: They allow repeated requests to be recognised as the same operation, helping prevent duplicate charges or orders.
Model answer: A browser script that can manage selected network requests and caching, enabling capabilities such as offline experiences.
Model answer: It defines valid states and permitted transitions, such as an order moving from draft to submitted, paid, fulfilled or cancelled.
Model answer: Response time, throughput, error rate, page weight, rendering delay and interaction responsiveness.
Model answer: A content management system that manages content separately and exposes it through APIs for different presentation channels.
Model answer: To limit privacy risk and collect only information necessary for a defined and legitimate purpose.
Model answer: Confirm deployed version, critical user journeys, error rates, integrations, logs, security configuration and rollback readiness.
Use these official organisations for curriculum guidance, examinations and further learning information.