Understand development and code
Development turns intent into behaviour. Separate document structure, browser interactions and server decisions. Define accepted inputs and output states before assessing a library or framework.
101 concepts to explore with definitions and practical advice.
Search the full glossary
A reading path
1. Structure and presentation
HTML describes elements; CSS organises presentation. Use components suited to the action before adding custom behaviour.
- HTML
Markup language giving content structure and meaning through headings, paragraphs, links, lists and form fields. Elements have roles and sometimes native behaviours. CSS primarily handles presentation, while JavaScript can add interactions.
- CSS
Language describing document presentation: layout, colours, spacing, typography and screen adaptations. The cascade determines which rules apply. A visual change does not transform an element’s HTML role: making text look like a button does not add button behaviour.
- Semantic HTML
Use of HTML elements according to their role: headings organise documents, links lead to destinations and buttons trigger actions. Meaning does not depend only on appearance. Correct semantics aids interpretation but still requires usable labels and behaviours.
2. Exchanges and contracts
An API describes expected exchanges. An endpoint, its inputs and responses should remain compatible with the journey using it.
- API
Interface defining how software exchanges data or requests operations. Its contract specifies inputs, responses and errors; knowing an address does not automatically grant access rights. Before integration, distinguish available operation, response format and permission. A technically received response may still contain an error or an incomplete result.
- Endpoint
API access point for a particular operation. Address, method and parameters form a usage to document; two methods at one address can have different effects.
- API contract
Documented agreement on an API’s inputs, outputs, errors and usage conditions. Defining versions and edge cases helps client software detect an incompatible change.
3. Errors and change
Test empty states, interruptions and unexpected input on a copy. Keep versions and checks needed for an update.
- Progressive enhancement
Approach providing essential content and functionality first, then adding capabilities according to browser support. For example, a linked list remains usable when its JavaScript filter fails. Define and test that baseline rather than assuming failures will be rare.
- Staging
Pre-production environment similar to the live website where changes are checked before release.
- Version control
System keeping file-change history, facilitating collaboration and allowing return to a previous state. Define which files are actually tracked and verify that a state can be recovered. Code history does not replace a backup of operational data.
Useful distinctions
Front-end / Back-end
Front-end covers the interface executed or rendered for the browser; back-end handles server processing. A visible interface check does not replace server validation.
API / Webhook
An API provides an exchange contract; a webhook sends a notification when an expected event occurs. The receiving system should account for repetition or delay.
Use the vocabulary to make a decision

Situation
A submission displays success but no record is retained.
Before deciding
Follow request and response, then the actual saved state. Separate the interface message from server confirmation.
A concrete check
Reproduce on a copy with test data and compare expected and observed results.
Distinguish the interface from the stored outcome
In a test environment, prepare a successful case and a rejected case. Compare the screen message, request response and state retained by the application.
On a narrow screen, scroll the table horizontally to read all three columns.
| Observed signal | What to check | What it means |
|---|---|---|
| Success appears after a server rejection | Compare status, response and the interface processing branch. | The message should reflect the received outcome. |
| An action happens twice | Try a double click and a retry after an interruption. | Processing should account for repetition in the journey. |
| Navigation disappears without JavaScript | Open a page directly and disable scripts. | Essential links and content can retain basic access. |
Next step : Write the expected result for each case before fixing it, then verify it again on the same site copy.
Technical reference : MDN — HTTP response status codes. The scenarios and numerical examples above are educational, not measurements of this website.
A browser check does not replace server validation
Fictional teaching case. Open each interpretation to examine its scope; there is no score or professional assessment.
- Input guided
- Request checked
- Business result confirmed
In a demonstration, a form reports an empty required field. The team asks whether the server can now accept all incoming data without further checks.
Which responsibility was observed?
A useful next step : Define useful interface feedback separately from server checks. Keep demonstration cases in an environment intended for testing.
Reference to explore : MDN · Website security · Consulted .
All concepts in this topic
Links open the full definition on its alphabet page. Acronyms and synonyms remain searchable in the main glossary.
- 404 page
- Algorithm
- AMP
- API
- API contract
- Asynchronous
- AVIF
- Back-end
- Baseline
- Bidirectional isolation
- Bot
- Broken link
- CacheStorage
- Catalogue facet
- Client
- Conditional request
- Correlation identifier
- CSS
- Cursor pagination
- Dependency graph
- Deployment
- DOM
- Dynamic content
- Endpoint
- Event-driven architecture
- Feature flag
- Form validation
- Framework
- Front-end
- Git
- GraphQL
- Head
- HTML
- HTTP 410 status
- HTTP header
- i18n
- IDE
- Idempotence
- iframe
- Incremental loading
- IndexedDB
- ISR
- JAMstack
- Java
- JavaScript
- JavaScript rendering
- jQuery
- JSON
- JSON Schema
- Lazy loading
- localhost
- Localized link
- localStorage
- Long task
- Middleware
- No-code
- Node.js
- Open source
- OpenAPI
- Paginated page
- Payload
- PHP
- Plugin
- Preflight request
- Progressive enhancement
- Progressive Web App
- Python
- Query string
- Redirect chain
- Render-blocking resource
- Rendering
- Responsive image
- REST API
- Semantic HTML
- Server-side rendering
- Service worker
- Session
- sessionStorage
- sizes attribute
- Source code
- srcset
- Staging
- Static site
- Storage Access API
- Structured logging
- Third-party script
- URL parameter
- URL rewriting
- Version control
- Web application
- WebAssembly
- Webhook
- Webhook delivery identifier
- Webhook retry
- WebMCP
- WebSocket
- WordPress
- XHTML
- XML
- XPath
- YAML
Frequently asked questions
Is a complex application always needed?
Choose functionality according to need and maintainability. A simple page or form may suffice; complexity is useful only when it addresses a real constraint.
Is JavaScript validation sufficient?
It helps guide input, but data and permission rules should also be enforced server-side. Test an input submitted outside the normal interface.
Primary reference documents
These documents explain technical concepts. Reading paths and examples are editorial methods to adapt to your project.