Vanilla JS Development | Anexia Digital Engineering

Vanilla JS development without framework weight.

Not every product needs React. Through Vanilla JS development, Anexia Digital Engineering writes small, robust JavaScript for web components, canvas, lean widgets and the core of design systems. The result is fewer dependencies, better Lighthouse scores and a tidier repository.

Small code, big effect

Modern browsers can now do much of what once required a framework, such as custom elements, shadow DOM, native dialogs and animation through the Web Animations API. Our Vanilla JS developers use these platform features consistently and build components that work in any framework or with none at all.

  • Web components & custom elements

    Your own HTML elements that behave like native tags. They work equally well in React, Vue or a CMS.

  • Bundle budgets under 20 kB

    We agree how large a widget may become and check it automatically with every build. For many widgets that is realistic when compressed.

  • Animation on the compositor

    Animations driven by the Web Animations API run on the browser's compositor, so they stay smooth even when the page is busy.

  • Building blocks for design systems

    Framework-independent components form the core of a design system and can be used in every product, whatever stack runs there.

Vanilla JS development at a glance

Vanilla JS means JavaScript without an additional framework, in other words the language and the interfaces every modern browser ships with. These include web components, shadow DOM, the Fetch API, the Web Animations API and much more. What once needed libraries such as jQuery is now often available directly in the browser. For organisations, Vanilla JS development is most interesting where performance, independence and a long lifespan matter more than convenience, for example in widgets and component libraries.

The payoff is clearest with widgets that run on other people's pages. Chat windows, booking widgets and low-tracking embeds need small bundles, must not cause global conflicts and have to encapsulate their styles cleanly. Other typical fields of use are documentation and marketing pages where performance comes first. For this work we use Vanilla JS, CSS, web components and Vite. When more interaction is needed, Alpine.js or a framework can extend what is there.

Why Vanilla JS development keeps you independent

For decision-makers, Vanilla JS above all means independence. No framework updates dictate the schedule, there are no lock-in questions, and code built on web standards keeps running for years. Because browsers stay backwards compatible, web components often last many years without changes, and maintenance is needed mainly when requirements change. That makes upkeep predictable and costs manageable.

What experienced Vanilla JS developers bring

Seniority shows in code review, not on a CV. Custom elements, shadow DOM, template elements and the Fetch API are available in every modern browser. We use them deliberately and add libraries only where they bring real value. Widgets running on client sites must shield themselves from foreign CSS and JavaScript. Shadow DOM, unique namespaces and defensive programming prevent conflicts.

Working without a framework gives full control over every byte, and we use it for measurably faster pages. That includes bundle budgets, lazy loading, animation on the compositor and economical DOM updates. A clear, versioned interface matters just as much. We document the attributes, events and methods of a widget or component library so other teams can use them without having to ask. For type-safe components and clean public APIs we add TypeScript where it helps.

Even without a framework, components must work by keyboard and make sense to screen readers. We implement ARIA patterns correctly and test them with real assistive technologies. For build and delivery, Vite, tree shaking, modern output formats and a clean CDN setup ensure that components load quickly and are easy to embed.

The business case

Vanilla JS pays off through low follow-up costs. Without a framework there are no regular framework upgrades, and components built on web standards often run for years without changes. Small bundles improve load times on your own pages and on your partners' pages. Framework-independent building blocks can be used in every product, whatever stack runs there. The result is components that are small, robust and independent of framework cycles, today and in several years' time.

Risks in Vanilla JS projects

Build on web standards and you no longer have to follow every framework cycle.

Transparency

Every kilobyte in view

Without a framework, every kilobyte counts. That is why we show every week how your components behave in use. You see the same figures as our team and decide on the next steps from there.

  • Bundle size per component
  • Load time and impact on the host page
  • Browser compatibility per test matrix
  • Error reports from production

A booking widget for partner sites

Consider a leisure provider that wants to embed its booking on hundreds of partner sites. The existing iFrame solution is slow and hard to adapt to each site. In a scenario like this we build a lean widget as a web component that loads only what it needs, adapts to each partner's design through attributes and leaves third-party styles alone.

New versions are rolled out in a controlled way, and partners embed the widget without any development effort of their own. For the provider this creates a sales channel that grows with little support effort, because the widget runs reliably and can be embedded without outside help.

How to recognise good Vanilla JS developers

For IT decision-makers, a few targeted questions are worth asking. Can the person encapsulate web components cleanly with shadow DOM, and how do they make sure a widget does not slow down third-party pages? Which browsers do they test, and how? How do they version and document public interfaces? And can they explain when a framework would be the better choice after all? Anyone who answers these clearly brings the experience that keeps Vanilla JS projects sound for years.

Key terms explained

Custom elements are your own HTML elements that can be used like native tags. Shadow DOM is the encapsulated area of a component that separates its styles and markup from the rest of the page. The Web Animations API is a browser interface for controlling animations efficiently from script. A bundle budget is the agreed upper limit for the size of the code that gets delivered.

What often fits alongside

Vanilla JS rarely stands alone. To modernise existing legacy code we combine it with broader JavaScript experience. If the server is to do most of the work, HTMX is the natural companion. And for type-safe components with clean public APIs for your widgets we turn to TypeScript, which compiles back down to standard JavaScript in the end.

Practice

Vanilla JS projects in practice

Where going without a framework pays off, and what the first weeks and months look like. Analysis, a first delivery and a clear plan, always aligned with your backlog.

Use cases

1 of 3

  • Widgets on many sites

    If your widget runs on hundreds of third-party pages, it must neither cost load time nor collide with foreign CSS. We build it small, encapsulated and robust.

  • One design system for all

    React here, Vue there, a CMS alongside. Web components provide building blocks that work everywhere.

  • Every millisecond counts

    For landing pages, campaigns and documentation, dropping the framework overhead lets you reach Lighthouse scores that are otherwise hard to sustain.

1 of 3

First weeks

1 of 3

  • Set the budget

    How large may the bundle be, and which browsers must be supported? Together we define measurable goals.

  • First component

    The first web component or widget goes into review with tests and documentation.

  • Component plan

    You receive a roadmap for further building blocks, for versioning and for delivery.

1 of 3

90 days

1 of 3

  • Goals & pilot

    The first month produces the bundle budget, the test matrix and the first web component or widget as a pilot.

  • Expand & secure

    In the second month more components follow, releases are versioned and automated tests run in every target browser.

  • Delivery at scale

    By the third month partners and product teams use the components on their own, backed by documented APIs, demo pages and a release process.

1 of 3

Questions on Vanilla JS development

Think ahead. Small bundles, long lifespan.

Tell us about your widget, your components or your design system and the browsers your users rely on. We show you where Vanilla JS development reduces dependencies and where a framework is the better choice after all.