Let's talk tech

A paradigm full of exciting and challenging computer science
is what draws us towards our passion of frontend architectures and reactive programming.

Let's dive into the technical aspect to understand the areas of complexity we are mastering.


The Modern Frontend is (in contrast to the old markup driven paradigm) a fantastic place filled with great computer science and difficult problems. It takes many skills to master the paradigm.

Declarative programming

Among the most important "skill" to master is within the paradigm of declarative programming.

Most reactivity is based on declarative principles, to bring reliable and predictable as well as readability.

This is one of the biggest changes from the old, imperative, frontend.

Concurrency theory

When handling reactivity different aspect of concurrency is very often in play. Whether it's perceived concurrency or proper multi threading, we face race conditions and timing issues where a solid foundation in concurrency theory is important.

Event Driven programming

We mostly think in events and subscription patterns. Our flow of programs are almost always determined by user actions. We often apply common event driven patterns to achieve maintainable and scalable architecture.

Graph Theory

When we dive a little deeper into the Modern Frontend, one of the very important but complex parts is dependency management. Within dependency management, graph theory is key to understand complex concepts such as phantom dependencies and dopplegangers.

Important techniques like chunking and tree shaking are also founded in graph theory.

Data structures

Of course data structures is a big part of a data consuming frontend application. Good and well scoped data structures lead to better and more predictable software.

Unit testing

Achieving the ability to deploy fast and frequently requires high confident in the software. This confidence can be achieved through well written unit tests.

In the frontend unit tests are more complex than known from a common backend application. The interface of consumption is often a user, a keyboard and a mouse. To maintain trustworthy tests, we need to follow same interface when testing our code. This makes it very important to understand what and how to test, to achieve the goal: If behaviour breaks, the test should break. If behavior is not broken, the test should not break either.

Type theory

Type theory is of course a given when working with software especially at scale. But this is not how it used to be in the old frontend.

When we build scalable architectures it often involves heavy use of generics and general polymorphism.

We've tried it over and over again, and know how much effort is saved by making code generic but more importantly modular and replaceable.

Compiler theory

Transpiling and compiling has become integrated parts of the modern frontend. Bundling and static site generation are also sharing "interests" with compilers.

UI, transitions & feel

And finally frontend is of course also about making pretty and performant user interfaces. It requires an visual eye for details and a good degree of perfection to master this area.

Now top that up with sophisticated design and style systems, integrated within the reactive, chunked page setup, and you actually get challenged!

Functional Reactive Programming

FRP is a declarative programming paradigm where we think in streams (you might be understanding our graphics now) and explicitly model time. It's extremely powerful to make very complex timings and concurrent executions predictable and maintainable.

Applications of FRP come in many shapes, but it's integrated parts of many frameworks (both frontend and backend). One of the most famous is ReactiveX which we are huge fans of.

Buzzword dictionary

  • "Scalability"
  • "Performance"
  • "Web Vitals"
  • "High performance teams"
  • "The JAM stack"
  • "MACH"
  • "The Edge"
  • "SSR" / "SSG" / "ISR"
  • "Serverless"

When we talk about scalability it involves multiple aspects. Some of these statements indicate a scalable setup

-Possible to work many devs in parallel
-Possible to contribute to the codebase without knowing it in full
-Possible to contribute to the codebase without breaking it

Single page application tools

  • react, solid, svelte, vue, angular

  • nextjs, gatsby, nuxtjs, sveltekit, solidstart


  • RxJS

  • Marbles

  • SignalR


  • Testing library

  • Jest

  • Marble testing

  • Vitest


  • Rush Stack

  • Heft

  • Api extractor

  • Typescript

  • Vite

Technologies we currently love

The frontend ecosystem is evolving fast. The technologies highlighted are the ones we currently enjoy working with.

We know a lot more technologies than the ones listed, so don't hesitate contacting us for any other requests.

Get in touch