Nicolas Ruflin

The pursuit of simplicity and automating everything is going to fundamentally change our world. Software is the key driver behind this. As an engineer at heart with a strong belief in science, I enjoy being part of this change and contributing to it. The fast pace of change is what pushes me forward on a daily basis.

My diverse backgrounds in Computer Science as well as Sports Science and playing the Cello allow me to look at problems from different angles and come up with creative solutions. Having fun doing what I’m doing is as important as getting stuff done. Constantly learning through reading, practicing and collaborating with peers is a valued part of my daily routine. Working with me means being able to handle new ideas on a daily basis and be challenged on rethinking existing principles.

Sports are my counterpart to computer science. I believe that both body and brain must be trained on a daily basis in order to work in sync and to be most productive.


Working together on a project, company or product means spending a lot of time together. A common set of principles build the foundation of every team and every company. The two principles that have proven to work for me are:

  • Simplicity
  • Automating Everything


Making decisions based on simplicity leads to beautiful and high-quality solutions. Crucial decisions should always be challenged by simplicity, as this reduces complexity in the long term. Reaching and keeping simplicity is hard work and doesn’t mean building simple solutions. Most of the time simplicity can only be reached through iterating complex systems and reducing them step by step.

Automating Everything

Software is fundamentally changing our world and daily lives. Even though software engineering is still a very young discipline, it has an impact on almost everything we do. The beauty of software is that it can automate and scale tasks. Coding means writing a process and making it infinitely repeatable. An algorithm which is written once can be run millions of times without the need of any raw materials or human interaction. This allows to not only double or triple the efficiency of a problem, but making it a thousand times more efficient and repeatable. Every task that has to be repeated multiple times should be replaced by software to minimize errors and save resources in the long term.

Companies & Experiences

In recent years I was able to gather experiences in various fields of Computer Science by building up my own companies, consulting for other companies and creating and contributing to open source projects. Consulting and working on open source projects allowed me to collaborate with dispersed teams on different continents. I broadened my cultural horizon by living in Peru, China and the US.

  • Centralway: As CTO & Managing Partner Technology I built up Centralway’s engineering teams to build and scale the technology and was one of the main drivers in expanding the company to about 100 employees.
  • useKit: As co-founder, I built the product from scratch, helped to scale it and built up an engineering team.
  • Xodoa: As founder of Xodoa, I have been consulting startups and SME in basic technology decisions as well as search and distributed storage systems. Furthermore, I have regularly been contributing to open source projects.

Furthermore, I gathered experience as player and coach up to the second highest Handball league in Switzerland as well as sports teacher in various classes of different ages.

Across the Interweb

If you want to know more about me or reach me, check out my online profiles. More information can be found all over the internet under the name “ruflin”.


I regularly speak at conferences, meetups or internal events on various technology topics. Some examples can be found below; more can be found on Slideshare.

Research Publications

Research and science are important contributors to push the innovation in the software engineering field forward.

Open Source Projects

Over the last two decades I contributed to a list of open source projects. My currently most active open source projects can be found on my Github profile. The most used and active project is Elastica.


I regularly organize internal and external meetups in order to bring together people with similar interest who can exchange and share knowledge. Meeting people allows to receive new inputs, views and ideas on existing assumptions.

Building Software

There are lots of different ways to build and run software. Over the years I have developed my own guiding principles which have proven to work well. These principles are based on the two main principles Simplicity and Automating Everything.

Small Teams & Iterations

Building software is a fast-changing environment. Technology and requirements change every day. Software should therefore be built in small, modular, composable and reproducible pieces. Accordingly, in line with Conway’s Law I see it as crucial to work in small teams, best teams of 3-5 people. As the utilized technologies constantly change, we should focus on principles and solutions and not be attached to a specific technology. Technologies are exchangeable and deciding for a technology always means making some trade offs as there is rarely a perfect solution.

Since every software project has a long list of unknowns, there is no master architecture that can cover all the details. Instead, building and improving software is an iterative process. Having an architecture with the principles and the building blocks that need to be built is crucial, but it is up to every engineer to find and build the right solution.

Moving Fast

The software we build and write today is outdated tomorrow. Software decays over time, especially when the source code is not touched. Nonetheless, every line of code is part of our application until the day we delete it. To ensure that the code keeps doing what we expect it to do, we can use tests. I see testing as a tools that allows us to move fast. With it, we can quickly and repeatedly test different scenarios in our code without having to spend time with manually testing it.

Tests should establish that code still works when we change other parts. As tests are a tool to move fast with confidence, we need to find a balance on how extensively we test the code without slowing down the project when things change.

Automation is another tool which allows us to move fast. Everything that requires lots of manual work, that is repetitive or prone to human errors should be automated. This pays off in the long run as it allows us to move quickly without having to worry about mistakes.

Moving fast also means lots of people will touch the same code. Writing readable and reusable code will make it easier for new engineers to quickly contribute to the code and will help yourself to use your code again later. Part of this is having documentation for the code, which is not necessarily self-explanatory. Write code for others, not yourself.

Every line of code is executed hundreds to an unlimited number of times. We value quality in everything we use that many times, so this must be true for software, too. Focusing on quality and simplicity from the beginning pays off in the long run.

Understanding Full Stack

It is crucial to understand the basic principles behind the full stack, since most applications nowadays communicate with other services through a network over a protocol. Problems with an application are not necessarily contained in the source code of the project, but can be in the network, on the environment or related to the dependencies of the project. Having an understanding for the basic principles behind the full stack makes it possible to build the system the right way from the beginning and in case of problems find and spot the errors fast.

As no person can be an expert in everything, it is important to share knowledge inside the teams and advise and support each other on the specific expert matters. This will allow every single team member to grow and evolve over time and allows to build better overall systems.

Systems will fail

Every system will fail at some point. This cannot be prevented through perfect planning or taking extreme measures. The only way to make systems reliable is to build them to be as resilient as possible. More than ever, the tools to build resilient systems are available. Systems must be built in a way to be able to recover from failures.


Immutability is a key corner stone of simplicity in building software. Everything that doesn’t change makes things more predictable. At the same time it can make building software harder, especially in the beginning. Immutability with source code versioning systems is already implemented in most software engineering teams today. Immutability on programming languages and especially on servers became more popular in recent years. Having containers and more programming languages supporting immutable data types provides new possibilities. With the increase of storage space available, also immutable storage systems are nowadays a feasible option. If you design your systems to be immutable, lots of problems are tackled in a different way, which leads to simplicity and resilient systems.

You get what you measure

Measuring and monitoring systems are crucial in order to understand how systems behave, what the status of a system is and if a system misbehaves. Metrics and monitoring are here to discover errors as early as possible, because the earlier an error is spotted, the faster it can be fixed. What you measure you try to make look good, which normally leads to improvements of the measured part. The big question is often what to measure, as almost everything could be measured in software. It is important to measure the full stack, starting with engineering cycle metrics such as technical standards, testing, continuous integration metrics but also production metrics such as exceptions, performance, errors and many more.

Having shorter cycles from engineering to building and shipping the code means faster feedback cycles. The faster the feedback, the faster bugs and problems are discovered. Continuous delivery is a crucial driver and should be implemented in a project as early as possible, as over time implementing these kinds of systems only gets more difficult.

Measuring has good and bad sides. It is very easy to draw wrong conclusions from certain metrics. Normally one metric alone doesn’t say much, but the combination of metrics gives good indications.

Open Source

I strongly believe in the benefit and power of Open Source. Open Source allows to share knowledge and fosters innovation. Most of the software I build is based on open source projects. In addition I try to contribute back whenever possible.

Areas of interest

There are a number of areas which will have a big impact in the future. Below are some of these areas which hold my biggest interest:

  • Search and distributed storage systems: Data sets will only grow. Converting data to information, knowledge and wisdom is key. Which companies will dominate the future?
  • Bringing hardware and software together: Making Technology disappear by bringing hardware and software together. Moore’s Law and 3D printing make it cheaper and easier than ever to build to hardware which will disrupt the hardware market in the next years.
  • Self Navigating Vehicles (Cars, Drones, Trains, Trucks, Rockets, …): This will fundamentally change our environment and our way life. Which companies will drive this change?
  • Software Development & Metrics: Making software development simpler and more predictable is crucial to handle the amount of software running the future.
  • Dispersed Teams: Driven by Self Navigating Vehicles, dispersed teams will be more common. Which technologies are still missing and which companies will master this on scale?

Related to my areas of interest, I like to keep a list of companies and technologies which I am especially interested in, either because I think they have the potential to have a big impact on our lives or because of personal relations. I update this list over time. If you want to know more why I put these particular companies on the list or you think one is missing, feel free to contact me so we can discuss it :-) There are lots of other large companies and technologies currently dominating the market which are not on these lists. In general I am convinced that the companies which not only manage to build a product, but to build a platform and even connect it to hardware will dominate the markets.



  • Blockchain: Distributed Database and Ledger with potential to bring simplicity to a variety of Industries
  • Docker: Distribute Application Platform
  • Elasticsearch: Data Processing platform