Chapter 1: Hello Vanilla Web
The introduction argues for choosing web tools based on project needs, explains the appeal of working directly with the browser, and distinguishes libraries from frameworks.
After this chapter you will be able to
- Intentional technology stack choices. Justify choosing a stack after understanding a project's requirements rather than defaulting to a familiar framework. Explain that libraries can be useful, but unnecessary dependencies may create security, performance, and maintenance problems.
- Direct platform control. Explain how working directly with the web platform makes an application more transparent and can give developers greater control over its architecture and maintenance.
- Modern platform and tool choice. Explain that Vanilla Web uses today’s HTML, CSS, and JavaScript rather than a separate framework or an outdated approach, and that tools can be added when they solve a project-specific problem.
- Vanilla Web approach. Explain that Vanilla Web starts with core web technologies rather than a framework-defined architecture, and works directly with browser features.
- Web standards building blocks. Describe the roles of semantic HTML, Vanilla CSS, Vanilla JavaScript, and HTTP in the section’s breakdown of Vanilla Web.
- Frontend layer and technologies. Describe what the frontend does and name the main technologies in a Vanilla Web frontend.
- Surrounding application stack. Trace the other layers in the typical stack and describe each layer’s role in relation to the frontend.
- User outcomes over tools. Explain why using new technology or Vanilla Web is not itself a goal, and identify the user and product outcomes that should guide a web project.
- Feasibility versus project fit. Explain why any website or web application can be built with Vanilla Web, while recognizing that this does not make it the best choice for every project.
- Good Vanilla Web candidates. Describe the kinds of projects the section identifies as good Vanilla Web candidates and the reasons it gives for choosing it.
- Vanilla and framework coexistence. Explain how a project can combine Vanilla Web code with a framework, either as separate parts of an app or as small pieces of code within a framework.
- Vanilla Skills as Foundation. Explain how learning Vanilla Web fundamentals helps developers work more effectively with frameworks and judge when a framework is needed.
- Direct Control and Transparency. Describe how writing Vanilla JS and CSS gives developers control over an application and a clearer view of what the browser is doing.
- Vanilla Web characteristics. Describe how the section characterizes Vanilla Web compared with large libraries and frameworks, and explain the developer-experience trade-off it identifies.
- Convenience and control trade-off. Explain why Vanilla Web can be simpler in the long run yet harder at the start, and when a framework may be a pragmatic choice.
Section by section
Introduction
The introduction argues for choosing web tools based on project needs, explains the appeal of working directly with the browser, and distinguishes libraries from frameworks.
- Intentional technology stack choices: Justify choosing a stack after understanding a project's requirements rather than defaulting to a familiar framework. Explain that libraries can be useful, but unnecessary dependencies may create security, performance, and maintenance problems.
Why it matters: It helps you make dependency choices for the project you have, rather than the tool you already know. - Direct platform control: Explain how working directly with the web platform makes an application more transparent and can give developers greater control over its architecture and maintenance.
Why it matters: Working closer to the browser can make the codebase easier to understand and less dependent on framework changes. - Library and framework distinction: Distinguish the general roles of a frontend framework and a library, including why the boundary can become blurred.
Why it matters: The distinction makes the chapter's discussion of tool choices more precise without treating the categories as rigid.
Key terms: technology stack, requirements, libraries, frameworks, dependencies, Vanilla Web, web platform, browser, hidden abstractions, technical autonomy
1.1 What Vanilla Web is not
The section dispels myths about Vanilla Web by presenting it as a modern, tool-compatible approach that can support efficient development and production apps.
- Modern platform and tool choice: Explain that Vanilla Web uses today’s HTML, CSS, and JavaScript rather than a separate framework or an outdated approach, and that tools can be added when they solve a project-specific problem.
Why it matters: It helps you distinguish starting with browser capabilities from refusing useful tools. - Developer-controlled modern architecture: Describe how Vanilla Web allows modular code, design patterns, reusable components, and modern testing while leaving architectural decisions to the developer.
Why it matters: It prevents confusing freedom from a prescribed framework architecture with a lack of structure. - Project speed and production viability: Explain why Vanilla Web can be quicker for simple to mid-sized projects and why it is not limited to hobby projects.
Why it matters: It frames speed and scale as project-dependent possibilities rather than automatic guarantees or limitations.
Key terms: Vanilla Web, web platform, HTML, CSS, JavaScript, framework, modular code, design patterns, reusable components, architecture
1.2 What Vanilla Web is
Defines Vanilla Web as building web experiences directly with web standards, identifies its main building blocks, and clarifies that it does not require rejecting useful tools.
- Vanilla Web approach: Explain that Vanilla Web starts with core web technologies rather than a framework-defined architecture, and works directly with browser features.
Why it matters: This is the distinction that makes the rest of the book’s techniques Vanilla Web techniques. - Useful tooling boundary: Distinguish avoiding unnecessary abstraction from rejecting all tools or writing everything manually.
Why it matters: It prevents mistaking a preference for direct web standards for a ban on practical tools. - Web standards building blocks: Describe the roles of semantic HTML, Vanilla CSS, Vanilla JavaScript, and HTTP in the section’s breakdown of Vanilla Web.
Why it matters: These building blocks show what developers use to make web experiences without a framework defining the whole process.
Key terms: Vanilla Web, core web technologies, DOM, browser features, tooling, abstraction layers, micro-libraries, pre-processors, Semantic HTML, Vanilla CSS
1.3 How it works
This section maps the layers of a typical Vanilla Web project and identifies the book’s focus on the frontend.
- Frontend layer and technologies: Describe what the frontend does and name the main technologies in a Vanilla Web frontend.
Why it matters: It identifies the part of the stack where most of the book’s work takes place. - Surrounding application stack: Trace the other layers in the typical stack and describe each layer’s role in relation to the frontend.
Why it matters: It puts frontend work in context without treating Vanilla Web as an entire prescribed server stack. - Frontend focus and backend choice: Explain where the book concentrates its effort and whether that focus requires a particular backend technology.
Why it matters: It clarifies the book’s scope and avoids implying that Vanilla Web dictates a backend.
Key terms: frontend development, Semantic HTML, CSS, JavaScript, Browser APIs, WebAssembly, Network protocols, Web Server, Backend development, Additional Services
1.4 Remembering our goals
This section argues for choosing web tools by user and product outcomes rather than by novelty, and explains why simple Vanilla Web projects may suit AI-assisted development.
- User outcomes over tools: Explain why using new technology or Vanilla Web is not itself a goal, and identify the user and product outcomes that should guide a web project.
Why it matters: Keeping the user's problem in view makes it easier to judge whether a technical choice helps the project. - Tool choice and developer experience: Describe how to weigh available resources and Developer Experience against product-focused goals when selecting tools, including the section's claim about Vanilla Web's viability.
Why it matters: This framing keeps tool selection tied to the project's needs rather than to an assumed winner. - AI development and project simplicity: Explain why the section suggests reconsidering Developer Experience for AI-assisted coding and what it recommends requesting instead of a framework by default.
Why it matters: A project structure that is easy for an AI agent to work with may change which tools are most useful.
Key terms: goals, conversion rates, usability, accessibility, performance, tool set, Developer Experience (DX), Vanilla Web, Web platform, AI coding agents
1.5 Using Vanilla Web
The section explains where Vanilla Web is a good fit while distinguishing technical feasibility from project suitability and acknowledging minimal use of helper libraries.
- Feasibility versus project fit: Explain why any website or web application can be built with Vanilla Web, while recognizing that this does not make it the best choice for every project.
Why it matters: It keeps the choice of Vanilla Web grounded in project needs rather than technical possibility alone. - Good Vanilla Web candidates: Describe the kinds of projects the section identifies as good Vanilla Web candidates and the reasons it gives for choosing it.
Why it matters: These examples give you practical criteria for judging when Vanilla Web may serve a project well. - Minimal helper library approach: Distinguish a strictly library-free Vanilla Web app from a “vanilla-ish” app that uses small helpers while remaining close to HTML.
Why it matters: It shows that the section treats minimalism as an approach, not just an absolute ban on libraries.
Key terms: Vanilla Web, Web platform, frameworks, libraries, content-oriented websites, landing pages, Core Web Vitals, performance-critical applications, DOM updates, vanilla-ish
1.5.1 Mixing Vanilla with libraries
This section explains that Vanilla Web code and frameworks can coexist in one application, and illustrates the approach with a small React-related fix and GitHub’s frontend.
- Vanilla and framework coexistence: Explain how a project can combine Vanilla Web code with a framework, either as separate parts of an app or as small pieces of code within a framework.
Why it matters: You need not abandon a framework to use a simpler browser-based solution where it fits. - GitHub’s mostly vanilla approach: Describe how GitHub uses web components alongside limited library use, and why the section presents this as a useful example.
Why it matters: GitHub provides a concrete large-scale example of selective library use alongside platform features.
Key terms: Vanilla Web, framework, browser APIs, custom elements, web components, web standards
1.6 Enhancing your skills
This section explains how working directly with web technologies strengthens developers’ skills, makes application behavior easier to understand, and offers a deliberate alternative to using a framework.
- Vanilla Skills as Foundation: Explain how learning Vanilla Web fundamentals helps developers work more effectively with frameworks and judge when a framework is needed.
Why it matters: Understanding the underlying platform remains useful even when your job uses a framework. - Direct Control and Transparency: Describe how writing Vanilla JS and CSS gives developers control over an application and a clearer view of what the browser is doing.
Why it matters: Direct control can make browser behavior and debugging easier to reason about. - Frameworkless Choice as Strategy: Explain why choosing Vanilla Web can be a deliberate architectural decision rather than a rejection of frameworks.
Why it matters: The choice of a framework can follow the project’s needs rather than being automatic.
Key terms: Vanilla Web, DOM, events, state, frameworks, Vanilla JS/CSS, markup, call stack, real DOM, browser inspectors
1.7 Characteristics
This section contrasts Vanilla Web with large libraries and frameworks by listing its main characteristics and noting a developer-experience trade-off.
- Vanilla Web characteristics: Describe how the section characterizes Vanilla Web compared with large libraries and frameworks, and explain the developer-experience trade-off it identifies.
Why it matters: This comparison gives you a starting point for evaluating the approach before the book examines its characteristics in depth.
Key terms: Vanilla Web, Developer Experience (DX), web standards, third-party dependencies
1.8 Challenges
This section explains the convenience-versus-control trade-off of Vanilla Web and identifies situations where its lack of built-in solutions can be a challenge.
- Convenience and control trade-off: Explain why Vanilla Web can be simpler in the long run yet harder at the start, and when a framework may be a pragmatic choice.
Why it matters: This trade-off helps you choose an approach based on a project's needs rather than assuming Vanilla Web is always easier. - Project fit challenges: Describe project needs that can make Vanilla Web harder to use effectively, including team coordination and demands for built-in capabilities.
Why it matters: Recognizing these constraints helps you judge whether Vanilla Web fits a particular team and application.
Key terms: Vanilla Web, short-term comforts, pre-built solutions, framework, structured architecture, complex DOM diffing, server-side rendering, strong typing
1.9 Summary
Where this is used later
- The power of Vanilla Web (chapter 2) · Develops the benefits of using the web platform.
- Application architecture (chapter 2) · Develops the application-architecture considerations introduced here.
- Building blocks (chapter 2) · The later discussion expands on the web platform’s building blocks.
- HTML, CSS, and JavaScript (chapter 2) · Expands on HTML, CSS, and JavaScript as web-platform building blocks.
- Working with HTTP (chapter 12) · Covers working with HTTP when communicating with a backend.
- Web performance (chapter 2) · The performance advantages named here are examined in more detail.
- Interoperability with libraries and frameworks (chapter 2) · Provides the basic coexistence claim for the later discussion of interoperability with libraries and frameworks.
- Working with events (chapter 6) · Applies the event-handling fundamentals named here through DOM APIs.
Concepts explained in this chapter
- vanilla webAn approach to building websites and web applications with core web technologies and browser APIs without a framework defining the application architecture.
- web platformThe collection of browser-provided standards and technologies, including HTML, CSS, and JavaScript, that support web application development.
- frameworkA reusable software structure that imposes conventions and supplies components for organizing application architecture and development.
- Document Object ModelThe browser programming interface for querying and manipulating a document's DOM representation.
- Web ComponentsA reusable custom HTML element built using browser standards such as custom elements, shadow DOM, and HTML templates.
- JavaScriptA programming language standardized as ECMAScript and widely used to implement behavior in web browsers.
- web standardsA public technical specification defining interoperable web languages, APIs, protocols, or platform behavior.
- CSSVanilla CSS is an approach to styling web interfaces with modern CSS directly, without CSS pre-compilers or core styling libraries.
- HTTPThe application-layer protocol used to transfer resources and messages between web clients and servers.
- semantic markupThe practice of using HTML elements according to their meaning to represent a document's content and structure.
- Web APIsA programming interface exposed by a web browser for accessing web-platform or device capabilities.
- performancePerformance is the speed, responsiveness, and resource efficiency of a software system during operation.
- developer experienceThe overall quality and effectiveness of a software developer's interaction with development tools, systems, and workflows.
- Custom ElementsA developer-defined HTML element registered through the browser's custom element APIs with custom behavior and lifecycle callbacks.
- micro-libraryA small software library providing narrowly scoped functionality.
- interoperabilityInteroperability is the ability of software systems or components to exchange and use information correctly across their boundaries.
- apiAn API surface is the set of interfaces and operations that software exposes for external use.
- server-side renderingGenerating HTML on a server for delivery to a browser.
- browser developer toolsBrowser developer tools are utilities for inspecting, debugging, testing, and profiling web pages and applications.
- cascadeThe CSS cascade is the rule system that resolves competing style declarations according to origin, importance, specificity, and source order.
- stateData representing an application's current condition and behavior.
- accessibilityThe degree to which a product or service can be used by people with varied abilities and disabilities.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
