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.

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.
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 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.
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.
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.
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.

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.
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.
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.
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.
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.
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.
1 of 3
1 of 3
1 of 3
Frontend development with React, Angular, Vue.js and Next.js for complex web interfaces. Fast, maintainable and accessible to WCAG.
Interactive menus, dialogs, calculators and multi-step forms with Alpine.js, right in the HTML and without a heavy framework. For websites that need to load fast.
Server-driven interfaces with HTMX for business applications that load quickly, ship little JavaScript and remain easy for backend teams to maintain.
Form-heavy web applications built on loaders, actions and progressive enhancement, plus a step-by-step migration to React Router.
Interaction concepts, prototyping in Figma, design systems, usability testing and accessibility to WCAG 2.1 for complex B2B software.
E-commerce platforms, customer portals, intranet & collaboration, IoT platforms and marketplace solutions - performant, secure and integrated.
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.