Because client-side validation is optional and rarely affects security in modern frameworks

Because server-side validation improves the visual appearance of web pages for users

Because server-side validation reduces network latency and speeds up form submissions

Because client-side validation automatically sanitizes all HTML and JSON data safely

Because a malicious user can bypass client-side checks and send data directly to the server

To store a backup copy of the original password in a separate database for verification purposes.

To strengthen password security by appending a secret and unique random string to each hash, slowing attackers and preventing reuse of identical hashes across accounts.

To add a unique random value to each password hash, making dictionary attacks and hash collisions more difficult.

To combine multiple passwords together so that users must enter several secrets at login.

To create a visually complex password that contains numbers, symbols, and capital letters automatically.

REST does not support caching or stateless interactions, which SOAP handles automatically.

REST can only be used with XML, limiting the formats supported for responses.

REST requires strict schemas and additional tools for request formatting and debugging.

REST mandates a single URL endpoint for all API requests regardless of resource type.

REST reuses standard HTTP mechanisms, making requests simpler without special libraries.

To transform REST APIs into XML-based services without additional coding.

To increase the speed of database queries for each endpoint automatically.

To bypass authorization logic implemented in individual microservices.

To eliminate the need for API versioning when endpoints are updated.

To centralize authentication and authorization checks for multiple services.

DELETE removes the resource entirely from the server or database at the specified URL.

PUT replaces the entire resource with the provided content or creates it if it does not exist.

POST triggers an action on the server, often creating a new resource or performing side effects.

PATCH allows updating only specific fields of a resource without sending the full content.

GET requests retrieve information without making any modifications to the resource itself.

To make the back-end API accessible publicly to all clients for easier integration.

To require every front-end request to access the back-end API directly without any intermediary.

To replace the need for any authentication or validation on both front-end and back-end layers.

To enforce that all front-end logic must be implemented in the back-end API layer.

To simplify front-end interactions with a complex back-end API while adding validation and security.

Because log streaming replaces the need for alerting systems entirely

Because streaming logs enable centralized aggregation and real-time monitoring

Because streaming guarantees that logs contain no duplicate entries

Because event streams automatically compress themselves without storage cost

Because page rendering depends directly on streaming log throughput

Because hashing makes stolen password data unusable to attackers

Because encrypted passwords automatically expire after a session

Because hashing allows faster authentication under heavy traffic

Because hashing requires fewer code changes during deployments

Because encrypted passwords synchronize more slowly across servers

Because TLS automatically compresses payloads for faster delivery

Because encrypted transport prevents manipulation or inspection of any transmitted data

Because HTTPS removes latency associated with round-trip communication

Because HTTPS forces clients to refresh tokens after every request

Because encrypted traffic disables caching to improve data freshness

Because mutability only affects frontend caches, not backends

Because immutable servers replace the need for application logging

Because immutable hosts automatically upgrade dependencies

Because immutability forces all apps to use the same database schema

Because immutability eliminates configuration drift between deployments

Because similarity reduces unforeseen failures during real deployments

Because identical environments confuse monitoring tools

Because staging should run on cheaper hardware to expose performance issues

Because mismatched environments automatically balance resource usage

Because production logic behaves the same regardless of environment differences

Because version tags determine which database schema is active

Because version numbers dictate server memory allocation policies

Because API upgrades automatically propagate when no version is defined

Because versioning allows changes without breaking existing client integrations

Because versioning eliminates the need for load balancing in microservices

Because rotating tokens increases the accuracy of analytics tracking

Because token rotation ensures faster garbage collection in memory

Because session tokens degrade visually when reused too often

Because token rotation is needed only when the UI theme changes

Because rotation limits the usefulness of a compromised token

triggers background scripts that conflict with ARIA(Accessible Rich Internet Applications) attributes by default.

correctly conveys action semantics to assistive technologies, improving accessibility.

automatically disables all keyboard navigation conflicts on complex pages.

tags are deprecated in HTML and cannot be styled consistently across browsers.

forces screen readers to ignore all nearby links, simplifying navigation.

It appears when formatted parameters collide with components and generate unintended operational outcomes.

It emerges when mismanaged request information blends with system routines and affects internal processing workflows in unpredictable ways.

It arises when validated data interacts with browser elements and unexpectedly shifts structural page logic.

It happens when trusted input is processed incorrectly and produces unexpected control behavior in modules.

It occurs when untrusted input becomes mixed with trusted data and alters how a query or command is interpreted.

It prevents costly redesigns later by embedding inclusive principles into every feature.

It mainly adds decorative enhancements that improve visual appeal for marketing.

It mostly eliminates the need for designers since tools automate accessible layouts.

It only matters for rare cases where external audits require last-minute compliance.

It generally replaces usability work because most users rely on assistive gadgets.

Validate input from users and sanitize output before displaying it.

Never validate input and rely solely on firewall protection against attacks.

Validate only administrative input while skipping normal users' data checks.

Always log user input without validation to ensure comprehensive auditing.

Sanitize input aggressively and ignore validation for faster processing.

To resolve incidents quickly, document actions, and identify underlying causes to prevent future occurrences.

To focus only on fixing the immediate issue without recording steps or analyzing causes.

To implement a comprehensive system of logging, monitoring, fire drills, and alerts while also tracking every minor change, user action, and dependency interaction to fully automate incident prevention.

To rely solely on external notifications from users or dependencies to detect system failures.

To separate development and operations completely, leaving incident resolution to dedicated operations teams.

Use a dedicated module to centralize API handling, including error reporting and caching.

Directly propagate all API errors to every part of the system without modification.

Ignore rate limits and retry all requests immediately to maximize throughput.

Make API calls in multiple locations without logging or monitoring for failures.

Avoid caching responses to ensure every request always hits the remote API.

It preserves meaningful structure that AT can interpret correctly without relying on visual styling.

It forces every component to use ARIA(Accessible Rich Internet Applications) roles even when native semantics already exist.

It ensures automated SEO tools apply fixed rankings regardless of content hierarchy.

It replaces the need for progressive enhancement because scripts handle all accessibility.

It mainly enhances decorative layouts that designers apply across responsive screens.

Keep them separate from source code, restrict access to a need-to-know basis, and rotate them regularly.

Store them in plain text on public repositories to allow easy access for automated scripts.

Use hidden URLs and obscure names for sensitive endpoints to ensure attackers cannot guess them.

Embed them directly in the source code to make deployment easier and reduce configuration steps.

Share secrets freely among all developers so anyone can debug or deploy without restriction.

200 OK indicates the request was successful and the response contains the expected data.

404 Not Found indicates the requested resource could not be located on the server.

201 Created indicates a new resource has been created successfully at a specific URL.

302 Found indicates a temporary redirection to another URL for the requested resource.

400 Bad Request indicates that the request was invalid or could not be processed properly.

To detect potential problems early through metrics and logs, allowing the team to respond before users are affected.

To collect large amounts of data primarily for post-mortem analysis without providing real-time alerts.

To replace the need for on-call staff by automatically fixing incidents without human intervention.

To rely solely on users reporting issues, such as social media posts, as the main indicator of system problems.

To track every technical detail, including all logs, metrics, and user interactions, for exhaustive analysis, even if it doesn't immediately prevent outages.

Separating build, release, and run ensures consistent, traceable deployments, enables predictable rollbacks, and prevents runtime failures caused by missing dependencies or on-the-fly asset compilation.

Keeping these phases separate prevents developers from tagging commits in version control, ensuring that configuration is always rebuilt dynamically whenever the service restarts.

Following this separation model ensures that all configuration changes automatically rebuild the source code, keeping every deployment perfectly synchronized with production edits.

Strict separation of phases guarantees that dependency servers never fail, eliminating the risk of downtime when restarting services on new machines or cloud-based virtual environments.

Distinct deployment phases are required because modern frameworks mandate performing all asset transformations during execution, ensuring runtime updates occur faster than prebuilt release bundles.

Encapsulate the data store behind a dedicated service that implements validation and exposes a consistent API.

Avoid any kind of validation or business logic and rely solely on external scripts for data correctness.

Use multiple separate databases for each component to reduce dependency on a single store.

Allow each application service to access the database directly to ensure flexibility in data handling.

Store all state in memory within the application tier for faster access and simplicity.

Return a structured JSON error message detailing the validation issues.

Ignore the error and attempt to process the request anyway.

Send the full server stack trace in the HTTP response for debugging.

Display a plain text message in the browser console only.

Always redirect the user to the home page without explanation.

Because encoding neutralizes script injection by treating malicious input as text.

Because encoding blocks all inline styling from loading on the page.

Because encoded output disables caching for security-related content.

Because encoding forces browsers to ignore all client-side logic.

Because encoded values increase CPU load making attacks harder.

Because actionable alerts let engineers focus on real issues instead of filtering distractions.

Because noise increases alert durability for long-term storage.

Because alert systems function best when thresholds are never adjusted.

Because alerts should always fire regardless of severity.

Because noisy alerts improve response accuracy by overwhelming the team.

Because nodes can be added without replicating unique local session data.

Because stateless nodes always run faster than stateful ones regardless of load.

Because stateless applications force clients to store all server logic.

Because statelessness removes the need for distributed tracing tools.

Because stateful apps cannot handle caching layers efficiently.

Because consistent formatting helps clients handle issues programmatically.

Because predictable structures reduce storage cost for archived logs.

Because error formats directly affect database indexing and search speed.

Because structured errors eliminate the need for API versioning entirely.

Because varied error formats improve logging diversity across environments.

It prevents unexpected focus loss that would otherwise send keyboard users back to the top of the page.

К сожалению нету вариантов учим этот варик

Because a system is only as secure as its weakest point, requiring careful planning to prevent unauthorized access.

Because adding security features at the end of the project is the most cost-effective way to ensure compliance.

Because security audits are only required for applications that process credit card payments or medical data.

Because most modern frameworks handle all security concerns automatically, requiring no input from the developer.

REST reuses standard HTTP mechanisms, making requests simpler without special libraries.

К сожалению нету вариантов ответа, учим это

Separate logs by concern, capture sufficient context for errors, and set meaningful metrics and alerts to detect issues early.

Log every single variable change and function call to ensure that nothing is missed, regardless of storage costs.

Store logs exclusively on the local server where they are generated to prevent network congestion.

Only enable logging after a crash has occurred to diagnose the issue retrospectively.

They allow the database to quickly locate records without scanning the entire table.

They automatically compress the data on the disk to save storage space, allowing more records to be stored on smaller hard drives.

They ensure that the data is encrypted at rest so that unauthorized users cannot read the raw database files.

They act as a backup mechanism, storing a duplicate copy of the table data in a separate location for disaster recovery.

They allow you to safely change the database structure while keeping data consistent.

They convert NoSQL databases into relational databases to simplify data handling.

They automatically improve the performance of all database queries without any developer input.

They permanently lock the database schema so no changes can be made in the future.

They remove the need for indexes and optimization by restructuring the entire database.

Because deployment constraints can affect design decisions like session storage and file handling.

Because deployment only matters after the application is fully built and tested.

Because continuous delivery and DevOps are only relevant for large-scale enterprise projects.

Because developers do not need to understand the environment their app will run in.

Because ignoring deployment considerations can not lead to scalability, storage, and operational issues that will not impact the application's stability and user experience.

It disables mouse events so that only keyboard navigation can trigger interactive behaviors.

It ensures that keyboard users receive the same visual cues as mouse users when an element is highlighted.

It converts focus rings into images that visually replace the standard browser outline.

It automatically generates ARIA roles for all interactive elements without extra markup.

It prevents search engines from indexing off-screen content created with CSS pseudo-elements.

Infrastructure should be manually tweaked after deployment to fix minor issues.

Once deployed, infrastructure and code are never changed; updates are made by replacing components with new versions.

Only the code changes, while the underlying infrastructure is modified in place.

Updates to infrastructure are made incrementally on the live environment to avoid downtime, rather than replacing it entirely with a fresh deployment.

Immutable infrastructure applies only to test environments, not production systems.

A key-value store retrieves data only by a unique key, while a document store allows queries based on the content inside the document.

A key-value store stores data in tables with rows and columns, while a document store stores all data as plain text files.

A key-value store always guarantees ACID(Atomicity Consistency Isolation Durability) transactions, whereas a document store cannot store structured data.

A key-value store is optimized for graph traversal, while a document store only allows sequential reads.

A key-value store is always distributed across multiple machines, whereas a document store must run on a single server.

Teams must deploy all changes manually to ensure safety and accuracy.

Automation eliminates the need for any configuration or environment management.

Feature flags allow changes to be deployed without testing or control.

Using DevOps automation forces all teams to use the same infrastructure, tools, and deployment schedule, regardless of project requirements or constraints.

Teams can deploy smaller, more frequent changes, reducing risk and speeding up delivery.

Define the architecture of a system and its interface contracts for distributed components

Create input validation and sanitization rules for all user-submitted data in web apps

Prioritize firewall rules and network configurations to reduce external attacks

Assign a score to threats based on damage, reproducibility, exploitability, users affected, and discoverability

Automatically generate checklists for code reviews without human verification

To ensure the server verifies a user's permissions before allowing access to specific actions or features.

To limit user access by controlling which front-end buttons and links are displayed for different roles.

To enforce fine-grained security by validating on the server side that every request matches the user's allowed actions and prevents any bypass attempts.

To hide certain functionality on the user interface so only selected users can see it visually.

To prevent unauthorized users from guessing URLs or endpoints by obscuring application structure.

Services can rely on local files for faster inter-process communication.

Using local files instead of network ports simplifies scaling, deployment, and independent process management across multiple servers.

Exposing interfaces via UNIX sockets is preferred for network scalability.

Port binding is unnecessary if all services run on the same server.

Communication should occur over the network, allowing services to run on separate machines.

Adding accessibility at the end allows developers to focus solely on visual design without interference.

Browsers automatically handle accessibility, so starting early has no practical impact.

Addressing accessibility early reduces rework and ensures all users can interact with the site effectively.

Accessibility features are only necessary for assistive technology users and can be optional initially.

Accessibility conflicts with APIs and should be implemented after backend development is complete.

Backing up the database only when critical failures occur, without any scheduled plan or monitoring.

Only performing full database dumps daily without any replication or real-time updates.

Relying solely on replication to a secondary server, ignoring periodic backups entirely.

Encrypting backups but skipping regular testing and monitoring of backup integrity.

Using both replication for real-time recovery and periodic database dumps for protection against all types of data loss.

Because backing services should always run on the same machine as the application for maximum performance.

Because the app must remain agnostic to where a backing service runs and communicate with it purely via configurable network locations.

Because treating backing services as internal components allows hardcoding hostnames directly into the code.

Because separating backing services enables environments where services may move between hosts, be replaced with simulated failures, or run in third-party infrastructures while the application still uses only configuration-defined network endpoints.

Because backing services cannot be swapped or redirected during testing without rewriting application logic.

The app must not store state locally and rely on an attached backing store for data.

Stateless execution allows local files or memory to persist indefinitely across all requests, improving scale flexibility.

State can be stored locally if the server has sufficient memory capacity.

Each script should terminate without using a backing store for files.

The app should keep session data in memory for faster response times.

Because foreign keys reduce application logic and remove the need for caching

Because foreign keys improve Ul responsiveness in large dashboards

Because relational databases require no validation when constraints are absent

Because they prevent inconsistent relationships and maintain data integrity

Because constraints only exist to reduce physical disk usage

Because runbooks reduce the need for logs in diagnosing failures

Because runbooks provide clear steps for resolving known classes of incidents

Because runbooks determine which services restart after deployments

Because runbooks eliminate the need for domain knowledge entirely

Because runbooks automatically sync across all deployed regions

Because the goal of incident analysis is to reduce monitoring alerts

Because post-mortems should measure Ul satisfaction rather than root causes

Because they encourage honest analysis focused on systemic improvement

Because incident reviews must primarily focus on rewriting user documentation

Because assigning blame helps identify which team needs fewer engineers

Because scalable schema models eliminate the need for indexes

Because schemas automatically rebuild themselves when structures degrade

Because relational constraints reduce performance under all conditions

Because poor schema design becomes expensive to correct as data volume grows

Because unplanned schemas work fine as long as queries remain simple

Because configuration rarely changes, so storing it in code has no effect

Because code-based config loads faster on multi-core processors

Because environment config makes deployment pipelines optional

Because embedding configuration risks exposing sensitive data and limits portability

Because environment variables reduce browser request sizes

Because hardware adds capacity automatically during downtime

Because planning ensures the system can handle expected load without degradation

Because unplanned scaling always leads to faster response times

Because capacity increases only when endpoints return HTTP 500

Because peak traffic reduces required memory usage

Because high-volume traffic negates the need for alerting

Because metrics remain accurate only when monitoring is disabled

Because proactive systems replace the need for traffic load balancers

Because monitoring reveals early signs of failure before they affect users

Because monitoring tools require user action to trigger events

Because hover effects require high refresh-rate displays to function correctly

Because hover styling always increases layout shift during rendering

Because hover-triggered events block focus indicators from appearing

Because hover states load additional fonts that reduce UI performance

Because hover actions exclude users on touch devices and keyboard-only navigation

Serve stale cache items while refreshing the cache in the background to reduce load.

Return an error to the user whenever any cached item is stale.

Store all API responses permanently without ever refreshing or expiring them.

Ignore cache entirely and rely solely on the API for every request.

Immediately remove expired items to always force fresh requests from the server.

Each service should have a single codebase in version control and explicitly declare its dependencies.

Dependencies can be mixed with system-level packages as long as the app runs correctly.

Isolating dependencies from system libraries can help in some cases, but it is only occasionally necessary and not always applied across all deployments.

A mono-repo should always be used to simplify deployment and eliminate separate repositories.

Multiple services can share one repository without isolating dependencies for simplicity.

To serve as a theoretical guide that teams rarely use during real production incidents.

To document every aspect of an application, including development decisions, architecture diagrams, and code comments, beyond practical incident response.

To store historical code changes and deployment logs for auditing and compliance purposes only.

To provide a clear set of actions and checklists for responding to alerts or incidents, reducing errors under pressure.

To replace monitoring systems by automatically detecting and fixing all errors without human intervention.

Use different deployment methods for each environment to ensure flexibility.

Deploying directly from source control without specifying dependencies ensures the latest code runs but risks inconsistent builds and runtime failures across environments.

Always SSH into the server and manually install dependencies before running the app.

Deploy a packaged version of the app rather than checking out source code directly on the server.

Skip packaging and rely on the dev environment to provide all runtime dependencies.

They ensure CSS frameworks automatically generate consistent visual layouts for advanced widgets.

They provide assistive technologies with semantic meaning that native HTML cannot convey in complex custom components.

They guarantee that all dynamic Ul updates are announced visually without requiring additional logic.

They allow developers to bypass semantic HTML so all elements can be freely styled as plain containers.

They replace the need for keyboard-friendly interaction patterns by simulating default browser controls.

Users may bypass intended workflows by guessing object locations without proper controls.

Users could accidentally trigger server errors by sending unexpected object references.

Users could exploit predictable resource identifiers to view, modify, or delete sensitive information without any access restrictions in place.

Users can access resources they are not authorized to by modifying a URL or object identifier.

Users might unintentionally break the application when interacting with files or links.

To ensure that users can inject any HTML or JSON content without limitations

To avoid validation and rely solely on trusted internal data handling mechanisms

To allow multiple parts of the system to apply different sanitization methods freely

To ensure data leaving or entering the system is safe and reduce risks of corruption

To make the system faster by skipping checks on external inputs in other modules

It only needs to include general advice and high-level guidance, leaving responders to figure out exact steps.

It should contain every possible technical detail about the system, historical logs, code references, and organizational changes, even if irrelevant for immediate incident response.

It should provide detailed step-by-step procedures, contact paths, and escalation instructions so responders can act correctly under pressure.

It replaces the need for an on-call system by automatically fixing any incident that occurs.

It primarily lists previous incidents without including specific steps or contacts for resolving new issues.

To force clients to maintain session data and track previous requests manually.

To ensure the server stores all user interactions for debugging purposes.

To simplify caching by keeping all responses identical regardless of headers.

To allow different clients to share state data automatically across requests.

To allow each request to be treated independently, enabling easier scaling across multiple servers.

Because trusted clients can still send malformed or unexpected data that can harm internal logic

Because input validation prevents caching mistakes in downstream services

Because validation mainly reduces payload size for improved performance

Because validation allows the API to automatically retry failed requests

Because trusted systems never change their behavior once deployed

It hides text visually while keeping it accessible to assistive tools that rely on the DOM.

It permanently removes the text from the document object model so that neither visual users nor screen readers can access the content.

It renders the text in a transparent font that is visible only when a user hovers over the specific element with their mouse cursor.

It encrypts the content on the client side so that it can only be decrypted and read by authorized accessibility software.

It guarantees that the website will load faster by pre-fetching resources whenever a user moves their mouse near a clickable link.

It ensures that keyboard users receive the same visual cues as mouse users when an element is highlighted.

It restricts the element's interactivity so that it can only be activated after the user has hovered over it for at least three seconds.

It automatically converts all mouse-based interactions into touch gestures for users on mobile devices.

To verify the user’s identity and ensure they have permission to perform requested actions.

To ensure that the API documentation is public while keeping the actual API endpoints hidden from search engines.

To encrypt the data in transit using SSL/TLS without requiring the user to provide any credentials or login information.

To allow any user to access administrative functions as long as they are connecting from a specific IP address range.

Once a transaction is committed, its changes remain even if the server is restarted or crashes.

It ensures that the database schema is locked and cannot be modified while a transaction is in progress.

It guarantees that all transactions are executed in a strictly serial order, one after another, to prevent any concurrency overlap.

It allows the database to automatically rollback a transaction if it takes longer than a specific timeout period to complete.

To verify user permissions on the server before executing specific actions

To restrict the ability of developers to push code to the production environment without approval from a manager.

To limit the number of functions that can be executed by the JavaScript engine to improve browser performance.

To ensure that only specific IP addresses can access the administrative login page of the application.

To remain independent of service locations and access them via configuration

To ensure that the application can only run on the specific hardware it was originally developed on.

To allow the application to automatically delete and recreate the database whenever the server is restarted.

To force the application to use a local file system for all data storage instead of connecting to a network service.

Minimizing differences reduces environment-specific bugs and increases confidence in deployments.

To allow developers to use their own personal computers as production servers to save on hosting costs.

To ensure that any security vulnerability found in development is immediately exploitable in production as well.

To make it easier for developers to manually copy files between environments without using version control.

PaaS offers simplicity with abstracted resources, while IaaS provides more control but exposes underlying complexity.

PaaS requires the user to manage the operating system and network configuration, while IaaS handles everything automatically.

IaaS is generally used for hosting simple static websites, while PaaS is required for running complex virtual machines.

There is no functional difference; the terms are used interchangeably by different cloud providers.

Continuous delivery ensures changes are ready for release, while continuous deployment automatically releases every change to production.

Continuous deployment requires a manual approval step before releasing, whereas continuous delivery is fully automated.

Continuous delivery is used for testing environments only, while continuous deployment is used for production environments.

Continuous deployment focuses on infrastructure updates, while continuous delivery focuses on application code updates.

The team as a whole is responsible for how the software behaves in production and must address any issues that arise.

To assign a specific person to be responsible for all server maintenance so developers can focus on coding.

To create a rigid barrier between the development team and the operations team to prevent miscommunication.

To ensure that the development environment is perfectly optimized, regardless of how the application runs in production.

Because hover actions exclude users on touch devices and keyboard-only navigation

Because hover effects consume too much processing power on older mobile devices, leading to battery drain.

Because modern design trends have moved away from hover effects in favor of flat design principles.

Because screen readers automatically block any content that appears only on hover to prevent spam

Identify usability issues and validate design assumptions early, before fixes become expensive.

Verify final accessibility and responsiveness.

Let users choose exact features

Test backend integration.

Optimize production code performance.

Define consistent visual and communication standards (colors, typography, tone) aligned with brand goals.

Document testing pipelines.

List deadlines.

Describe technical architecture.

Specify backend integrations.

Helper classes.

View model.

View.

Controller.

Model.

Embed logic inside each module.

Distribute a shared library everywhere.

Avoid HTTP/REST.

Duplicate logic across services.

Centralize business logic in one place so changes don’t require updating multiple components.

Focus only on front end coding.

Manage only visual branding.

Follow management hierarchy.

Ensure site structure and naming reflect user needs, breaking silos and improving usability.

Maintain databases.

Send CSS/JS only to mobile users.

Bundle third party IFrames by default.

Ensure all users get a basic experience, with enhanced features enabled when supported.

Replace server side rendering entirely.

Auto generate HTML from XML.

It guarantees no performance impact.

It merges all CSS and JS automatically.

It allows the component to be deployed and managed independently of the parent page.

It eliminates the need for a URL.

It avoids query parameters.

Estimating budgets and timelines.

A prioritized list of things to work on that guides the team’s work during sprints.

Tracking defects only.

Recording completed features.

Defining daily tasks per developer.

Add all technical debt tasks as low priority maintenance items.

Express technical debt as user stories written in stakeholder friendly language describing outcome and value.

Use time boxed tool time exclusively.

Wait until retrospectives to decide.

Create a separate technical backlog only developers manage.

Pages → Templates → Organisms → Molecules → Atoms

Templates → Pages → Atoms → Molecules → Organisms

Atoms → Molecules → Organisms → Templates → Pages

Organisms → Atoms → Templates → Molecules → Pages

Molecules → Atoms → Pages → Templates → Organisms

They cannot function without an active internet connection.

They rely entirely on native OS components.

They are distributed directly from servers to clients at the point of request, simplifying updates and maintenance.

They require users to manually install new versions.

They are designed only for desktop computers.

A process that replaces developers and business analysts.

A multidisciplinary practice that centers users, combining HCI, visual and interaction design, research, and information architecture.

A role that solely writes content.

A discipline focused only on pixel perfect visual designs.

A narrow field concerned only with the final UI.

Retina pixels, because only they are relevant for all devices.

CSS pixels, because responsive design dimensions are based on them, not physical display pixels.

Device DPI, because it replaces CSS pixels entirely.

Physical pixels, because they determine the actual resolution of the screen.

Browser zoom level, because it determines how pixels are scaled.

Interfaces should contain as many methods as possible to reduce the number of classes.

Dependency injection should be avoided to simplify code management.

Modules or classes that implement the same interface can be used interchangeably without breaking assumptions about their behavior.

Modules should always require additional parameters to make them more flexible.

All subclasses must modify the behavior of the parent class to add new features.

Scaling a microservice requires duplicating the entire system on multiple machines.

Microservices are easier to build initially than monolithic systems.

Internal components communicate implicitly, reducing the need for APIs.

A microservice combines all system functions into a single codebase.

Each microservice can be deployed and scaled independently, promoting flexibility and adaptability.

It limits developers to working only within their specific technical domain.

It focuses primarily on deep specialization in one layer of the technology stack.

It defines “digital” businesses as those that outsource all technical work.

It separates development and operations to reduce complexity.

It emphasizes teams of T-shaped developers who understand both technology and business to deliver complete solutions quickly.

To replace Test-Driven Development entirely with natural language tests.

To ensure that every requirement is documented in a large Word functional requirements document.

To let developers independently define both requirements and tests without stakeholder input.

To create a shared understanding between the development team and business/UX stakeholders using executable or traceable specifications.

To remove the need for automated tests by relying solely on manual QA.

WebSockets eliminate the need for API authentication by using server trust.

WebSockets allow two-way communication without creating a new connection for each message.

WebSockets automatically cache all server responses to reduce network traffic.

WebSockets convert all JSON responses into XML for easier parsing in browsers.

WebSockets guarantee message delivery even if the client loses connection temporarily.

It guarantees that AT tools skip elements automatically regardless of their position.

It prevents screen readers from detecting dynamic updates triggered by scripted UI changes.

It forces all interactive elements to require ARIA(Accessible Rich Internet Applications) roles even when native semantics exist.

It disables default focus behavior so custom JavaScript handlers must replace it.

It can create inconsistent navigation order that breaks alignment between visual flow and DOM structure.

To review technical documentation and update the backlog accordingly.

To assign new roles and responsibilities within the development team.

To assign new roles and responsibilities within the development team.

To reflect on the team's recent work, identify what went well and what went wrong, and define actions for improvement.

To report sprint outcomes to upper management and stakeholders.

Kanban does not use fixed-length sprints; work flows continuously as tasks move between stages.

Kanban focuses on producing potentially shippable increments every two weeks.

Kanban requires teams to plan sprints in advance and commit to a set of backlog items.

Kanban eliminates the need for task boards or daily standups.

Kanban requires certification similar to a Scrum Master qualification.

To eliminate the need for testing before deployment.

To store unfinished features until a major release is scheduled.

To delay deployment until all stakeholder reviews are completed.

To roll back bad releases instead of fixing them.

To minimize the time and friction required to move an idea from concept to production.

It guarantees that all system-level dependencies will behave correctly.

It allows you to test functions over a wide range of inputs, automatically checking many edge cases.

It replaces unit tests entirely with manual QA.

It is only useful for testing user interface components.

It requires explicitly specifying every possible input and output for a function.

It eliminates the need to consider non-digital components like shipping or printing.

It reduces the need for an API to wrap business logic in the persistence layer.

Separating interactions allows each component to grow and change independently without introducing risks to unrelated parts of the system.

It simplifies CRUD frameworks by automatically generating all code in one controller.

It allows external dependencies to be ignored in system design.

Only collect data that is necessary and meaningful, minimizing risk to users

Prioritize organizational needs over cultural or legal privacy expectations

Assume anonymized data cannot be traced back to individuals

Collect as much data as possible to find potential trends later

Ignore user consent if data is valuable for business purposes

Following exact client specifications guarantees successful software.

Planning should focus mainly on producing detailed documentation.

Building the right thing for the user is more important than merely building the thing right.

Developers exist solely to write code and not to engage in planning processes.

Writing perfect, elegant code is always the top priority regardless of user needs.

To load CSS before HTML to guarantee styles are applied.

To force browsers to use legacy JavaScript for compatibility.

To bypass JavaScript entirely and rely only on server-side rendering.

To ensure all users see the exact same interface regardless of browser capabilities.

To enable certain functionality only when the corresponding feature exists in the browser.

Ensure users spend as much time as possible interacting with the app

Minimize cognitive load and avoid dark patterns that negatively impact users

Delegate all ethical considerations to management or legal teams

Prioritize business goals over usability in all cases

Focus only on technical correctness, not user experience

To delay bug discovery until the end of the sprint for more comprehensive reporting.

To follow test scripts without understanding the product or user behavior.

To create large, detailed test plans that are rarely executed.

To replace automated testing entirely, ensuring all tests are done by humans.

To identify unexpected behaviors, perform exploratory testing, and complement automation by focusing on complex or emergent system interactions.

A process that replaces developers and business analysts in defining system behavior.

A multidisciplinary practice that centers users, combining human-computer interaction, visual and interaction design, research, and information architecture to design holistic systems and experiences.

A narrow field concerned only with the final UI, not with research or system structure.

A discipline focused only on making pixel-perfect visual designs exported from tools like Photoshop.

A role that solely writes content and ignores interaction or technical constraints.

Always choose the newest and most popular programming language regardless of team experience.

Use languages and frameworks that are already in use in other components to reduce context switching and increase team efficiency.

Avoid using libraries, as they are less flexible than frameworks in all cases.

Select frameworks that force you to rewrite existing components to fit their patterns.

Only focus on the programming language and ignore frameworks or libraries.

To increase the number of dependencies in a system for flexibility

To rewrite code entirely in a new programming language

To add new features to an application regardless of existing code

To improve the internal structure of code without changing its functionality or interface

To remove all test cases and simplify development

Strive to do no harm or at least minimize harm in their work

Follow legislation strictly, ignoring personal or societal ethics

Ensure all users' data is collected and stored for organizational benefit

Avoid learning from other professions' codes of conduct

Prioritize company profits over privacy concerns

Internal components communicate implicitly, reducing the need for APIs

A microservice combines all system functions into a single codebase

Each microservice can be deployed and scaled independently, promoting flexibility and adaptability

Scaling a microservice requires duplicating the entire system on multiple machines

Microservices are easier to build initially than monolithic systems

Because developers usually skip the discovery phase when creating stories.

Because stories that meet INVEST immediately are considered over-specified and therefore discouraged.

Because INVEST principles only apply to completed features, not new ones.

Because the INVEST criteria are only relevant during the testing phase of development.

Because new stories often serve as placeholders that still need refinement to identify value or gather enough information to make them estimatable.

To have a committee review every proposal before it is implemented.

To finalize all specifications well in advance before any development begins.

To create a shared understanding between product representatives, developers, and testers to define acceptance criteria or executable specifications.

To allow testers and developers to guess requirements without business input.

To replace natural language acceptance criteria with only code-based tests.

To create user interfaces before any backend logic is written.

To replace integration testing with unit testing entirely.

To ensure every possible scenario in your application is automatically tested.

To allow tests to run only after the application is fully developed.

To use tests to drive the design of your code, not just to generate test coverage.

To ensure the website looks exactly the same on all devices regardless of screen size.

To hide keywords in the content to manipulate search engine results.

To make the content easily understandable by search engines so it ranks highly for relevant terms.

To rely solely on JavaScript to display content for search engines.

To maximize the use of images and videos without any textual content.

Automated screenshot comparisons never produce false positives.

Manual testing is unnecessary when using any automated visual testing tool.

The human eye is the best tool to verify the look and feel of a web page.

Selenium can perfectly verify all visual aspects without human intervention.

Browser differences do not affect automated visual tests.