Join worldclass industry experts who discuss the future of Server Side Engineering. Tickets going fast, act now.

get Tickets

Conf 2019

Join us for discussing the latest technology, climbing mountains, and building new friendships. WorkerConf is the place to talk about the future of micro-services, server-side rendering, performance monitoring and tuning, edge computing and upcoming features of JavaScript.

A number of hiking trails inform about nature, fauna or the characteristic traits of alpine farming. Get ready for four days of workshops, talks and hiking on 27th to 30th of June 2019.


Matteo Collina
Node.js TSC Member
Thomas Würthinger
Dan Ehrenberg
TC39 participant
Julie Ng
Microservice Architectures
Patrick Stapfer
Reason Association
Olga Skobeleva
Edge Computing
Webpack and React
Vanessa Böhner
Tim Neutkens
Tomas Della Vedova
Node.js, Fastify, and Elastic Client
Sarup Banskota
Tierney Cyren
David Mark Clements
MC JoeMoe
Product Owner


27.06 Workshop Day

13:00 - 17:00
Seamless deployment experiences with Now
Sarup Banskota

Now is a global deployment network built on top of all existing cloud providers. It makes teams productive by removing servers and configuration, giving you a seamless developer experience to build modern scalable web apps.

In this workshop, we will go all the way from setup to deploy.

Among other things, we will learn to:

• Set up Now platform

• Deploy a variety of examples on the Now platform

• Easily set up integrations to get automatic staging, dev and prod

• Not to worry about provisioning or renewing SSL for projects again

This workshop is beginner-friendly.

13:00 - 17:00
Patrick Stapfer

In this workshop, Patrick will introduce you to the ReasonML platform to build highly type-safe ReactJS applications with the BuckleScript JavaScript compiler.

The goal of this workshop is to build a little webapplication, with following rough outline:

  • Setting up the Development environment (VSCode)
  • Little introduction to the ReasonML platform
  • NextJS as the basis for our application
  • Write our first ReasonReact components to build simple UI
  • Use React-Hooks to build our first stateful component ("UI where we can click and change stuff")
  • Use Prismic.io CMS to provide some data via a GraphQL endpoint
  • Wire up the data fetching within our React application (we will use graphql_ppx to make our GraphQL queries type-safe)
  • Add some styling with TailwindCSS
  • Extra (optional): Use now to deploy the app to the cloud

In the end you will have an idea on what Reason is about and you will also be able to build your own ReasonReact components, which can either be used in a standalone ReasonReact application, or may be integrated in any existing ReactJS app.


  • VSCode + installed reason-vscode plugin by Jared Forsyth
  • Preferrably MacOS / Linux based systems, but Reason + BuckleScript generally works on all platforms
  • Basic understanding of ReactJS
13:00 - 17:00
Take your monolith to microservices with Fastify
Matteo Collina
Tomas Della Vedova

We all know the problems of migrating a monolith to a microservices architecture. Mixed logic, cross-dependencies and way too many edge cases to test. Wouldn’t be great to have a framework that helps you build a modular, consistent and pluggable system? Enter Fastify, a new web framework for Node.js. Fastify offers an extremely flexible plugin system that allows complete customization of the framework. Every plugin could be packaged as an independent module and then deployed as microservice or as a part of a monolith. In this workshop, we will discuss and then implement the key elements of an Enterprise Node.js application, such as tracing, logging, database connectors, testing and code reuse.

16:30 - 18:30
Nuxt.js - VueJS SSR Workshop
Vanessa Böhner

Topics adressed in this workshop:

📚 What Nuxt.js is and how it can help you and your projects

💻 Starting new Projects with create-nuxt-app tool
📚 The structure of a Nuxt application
💻 Creating and navigating between pages
💻 Fetching data: client-side and server-side
💻 Storing data with Vuex
💻 Creating dynamic routes with payload
💻 Setting up meta tags for improved SEO
💻 Switching between layouts

⚒️ Optional: Deploy your apps to Heroku and Netlify

28.06 Conference Day

Checkin and breakfast
Keynote - Ultralight Java Microservices with GraalVM
Thomas Würthinger

GraalVM is a universal virtual machine for running applications written in JavaScript, Python, Ruby, R, JVM-based languages like Java, Scala, Kotlin, Clojure, and LLVM-based languages such as C and C++. One exciting feature of GraalVM is its capability of performing ahead-of-time compilation of programs written in JVM-based languages into native images. The resulting binaries are extremely lightweight in terms of memory footprint and startup time. This enables new architectures for microservices written in Java, Scala or Kotlin.

This talk describes how the GraalVM native image generation works under the hood. Furthermore, it will demonstrate its capabilities with examples of popular microservice frameworks like Quarkus, Micronaut, or Helidon. Join and experience live how this is a game changer for running server-side JVM-based applications!

JavaScript Class Features: A case study in TC39
Dan Ehrenberg

ES6 classes were intentionally minimal, containing only  public method declarations. Now, TC39 is considering adding several  other features to classes: private, fields, and decorators. In this talk, we'll see how these proposals work in detail, the process that got  them there, and how you can get involved. TC39 needs your help to build features like these and the future of JavaScript.

JavaScript - Quo Vadis

JavaScript, where are you going? During the past decade, the usage of JavaScript has exploded. The real question is, where does all this lead to? In this lightning talk, I will give you some FUD for thought and challenge you to think what the future of JavaScript might look like.

Visualizing cloud architectures in real time with d3.js
Julie Ng

If you have multiple development teams, your cloud architecture probably feels organic changing with agile development cycles. We may ship faster and scale faster. But we can also get lost more easily as complexity grows. Automated monitoring tools come at the price of information overload.
Let's bring some clarity back into the picture by filtering out the technical noise to see how cloud architectures were designed to behave. We'll create our our own microservice architecture visualization frontend using d3.js. Then we'll integrate some backend monitoring, sprinkle in some animation with JS and CSS, and voilà - we can watch how our architecture dances - in real time!

Lunch break
Next.js: The React Framework
Tim Neutkens

63% of npm users are using React. Making it the most popular JavaScript framework ever. React is being used everywhere from your favorite websites and web applications to maybe your personal website. However building fast and scaleable React applications is complex. There are many pieces that have to come together, from compilation to optimization to developer experience. Furthermore there are many strategies in which websites and applications are being built today, for example statically pre-rendering, server-rendering and client-side only rendering. Let's explore how Next.js solves all of these problems for you.

Server-Side Rendering using Nuxt.js
Vanessa Böhner

Nowadays frontend developers need to know several JavaScript frameworks, bundlers and package managers. Additional, for full stack power, they should be able to write a server with nodejs (or similar), configure all the interfaces between Backend and Frontend and then hope that it will work. The purpose of Vue.js and Nuxt.js is to let developers focus on implementing an application and creating features again. They provide solutions and configurations for the magic in between. In this talk we will see how Nuxt.js allows us to easily render a website on the server-side and how it simplifies the development.

Speeding Up React SSR with ESX
David Mark Clements

React is a hugely popular frontend framework that revolutionized the frontend development world. React is built primarily for the browser, while Node has fundamentally different operational constraints to the browser. As a Principal Architect and Consultant it has become painfully clear that React's Server-Side Rendering is a performance bottleneck for web backends around the world. This talk presents and demonstrates a very simple solution that can be dropped into pre-existing React applications to significantly improve Server-Side Rendering throughput.

⚡Talk - JavaScript: The fairly odd parts (explained)
Benedikt Meurer

JavaScript is the new language of choice for many applications, and it’s certainly a great language for many tasks. But it also has some strange quirks. This lightning talk focuses on one particularly weird aspect of JavaScript, that you usually don’t run into… unless you try to implement a JavaScript VM that correctly follows the language specification.
And as a bonus we're going to explore the underlying mechanics this time and explain what's going on behind the scenes.

⚡Talk - Benchmarking inside and out
Tomas Della Vedova

Benchmarking is an important component of writing applications, libraries, and all code in between. There is never a perfect formula for how to measure the performance of your code, as the requirements vary from codebase to codebase. Elastic has an entire team dedicated to measuring performance of Elasticsearch and the clients team has worked with them to build a common benchmarking framework for itself. This talk will show how the performance of a complex distributed system is measured and how a similar approach is used to benchmark the Elasticsearch JavaScript client.

Automating Your Vulnerabilities Away
Tierney Cyren

Your production Node.js applications are insecure. These vulnerabilities aren't coming from the module ecosystem, as you may expect – they're coming from your own engineering practices. Node.js versions are the root cause of vulnerabilities in production that your team isn't managing effectively. But, there's a light at the end of the tunnel – that light is automation.

The Node.js project actively ships updates often and with notice, and does their best to effectively communicate the changes that specifically revolve around security releases. Nevertheless, your Node.js versions are a few releases behind because your app _works_ regardless of the Node.js version that's running – as such, upgrading is a lower priority than literally anything else you could possibly be doing.

In this talk you'll learn about the resources that are currently available to help you and your ops team keep your Node.js versions up to date, covering your apps from being attacked with publicly disclosed vulnerabilities.

Reason: A ML language for the Masses
Patrick Stapfer

JavaScript plays an important role in everyday’s software engineering, and a lot of engineers already discovered the advantages of modern type systems to scale their codebases more easily.

ReasonML is a language and ecosystem which takes type safe codebases to the next level. It’s a functional programming language based on OCaml (ML), which empowers the user to write highly efficient ReactJS applications and to compile down to extremely fast single executables.

In this talk, you will learn how Reason can be a new tool in your toolchain to build mission-critical apps with stronger guarantees in runtime safety, a familiar syntax with a lot of functional programming features and different use-cases to compile to different platforms.

Dinner Break
Stream into the future
Matteo Collina

There was a time when Node.js streams were all the rage but over time the Node.js Core Streams codebase became extremely complex and hard to understand. Worse still, WHATWG introduced an API for browser Streams. The two Streams API’s are incompatible with each other and both are complex and leaky. In this talk, a Node.js Core Streams maintainer presents a stream-less future by demonstrating how to use pure JavaScript: Async Iterators and Generators can give us everything Streams can while being completely cross-platform and highly performant.

Keynote - Security: the serverless future
Olga Skobeleva

Network-based serverless is the future of how complex software systems and their security will be designed and built. You can already start offloading security features to the edge today in order to increase performance and ease the systems maintenance. Whether it's a simple insertion of HTTP security headers, management of bot traffic (eg. scraping), API Gateway protection or full-blown user authentication and authorization. There is a tool that can deploy it across a global anycast network in under 30 seconds.

Cloudflare has been offering some out-of-the-box serverless security for a while now, but in 2017 the company has released Workers - a V8 powered FaaS environment that offers not only an ability to built full serverless applications, but also deploy separate security functions to Cloudflare's global anycast network. At Cloudflare we make sure that security doesn't come at a cost of performance and this talk will go through several security offloading cases that will show you the power of Cloudflare Workers.

Drinks & Chat

29.06 & 30.06. Activity Day

Hiking and Outdoor activities. Read more


Be part of the WorkerConf experience.
Get unique inspiration from world class engineers.

Call the Guntram (+43 677 62 77 4626) if this text is visible...

Partners &


Vorarlberg. A place where high tech and mountains meet.

Worker Conf inspires the alpine developer community. Engineers run workshops and speak in sessions about their projects and innovations.


Rhombergs Fabrik
Färbergasse 15
6850 Dornbirn, AUSTRIA

Get unique inspiration from world class engineers.

© 2019 Alpine Conferences. All Rights Reserved.