Dependency Injection (DI) addresses a simple but critical problem: keeping your code manageable. Without it, you’re stuck with tightly coupled components, like a Car class that directly creates its own Engine.

Initially, this seems fine. But what happens when you need different engines, gas, electric, or something new? Suddenly, your Car class has to handle creation logic, breaking its focus and making changes a nightmare.

DI changes the approach. Instead of creating its own dependencies, the Car gets its Engine from the outside. This keeps your code focused, flexible, and easy to test. Swap an engine? Update a configuration? No problem.

You don’t need a fancy framework to do DI. But frameworks like Spring automate the wiring, saving time. The payoff? Cleaner code, fewer headaches, and a codebase that doesn’t fight you every time something changes.

From the outside, it might seem like magic. Here’s how you can implement it yourself.

The canonical Spring example

The simplest example consists of a (Spring) component MessageConsumer which depends on another (Spring) component MessageProvider, which in turn does not have any further dependencies. When starting the application, the run method from the consumer is called since it implements CommandLineRunner:

 1// Main.java
 2import org.springframework.boot.SpringApplication;
 3import org.springframework.boot.autoconfigure.SpringBootApplication;
 4
 5@SpringBootApplication
 6public class Main {
 7    public static void main(String... args) {
 8        SpringApplication.run(Main.class, args);
 9    }
10}
11
12
13// MessageConsumer.java
14import org.springframework.boot.CommandLineRunner;
15import org.springframework.stereotype.Component;
16
17@Component
18public class MessageConsumer implements CommandLineRunner {
19    private final MessageProvider messageProvider;
20
21    public MessageConsumer(MessageProvider messageProvider) {
22        this.messageProvider = messageProvider;
23    }
24
25    @Override
26    public void run(String... args) {
27        String message = messageProvider.getMessage();
28        System.out.println(message);
29    }
30}
31
32
33// MessageProvider.java
34import org.springframework.stereotype.Component;
35
36@Component
37public class MessageProvider {
38    public String getMessage() {
39        return "Hello, world";
40    }
41}

In the following sections, we will implement our own dependency injection framework. Our goal is to allow seamless switching of import statements to our implementation without any other changes. The example should still function as expected.

Our goal:

Our own implementation

Spring’s DI framework offers extensive functionality, much of which is beyond the scope of this educational example. Let’s begin by clarifying what we won’t implement, though much of it is straightforward:

• Lifecycle Management. No support for @PostConstruct, @PreDestroy, …
• Scope Management. We only support singletons. Adding additional types such as Request, Prototype, Session would be possible by adding a dedicated ApplicationContext and appropriate methods. Since we do not support @Controller in our small example, these do not make sense anyway.
• No Aspect-oriented programming (AOP). This might be a bit more tricky and will probably be covered in a future post.
• No field or method injection. Technically, trivial to implement, but would just blow up the code without providing additional insights.

… and, as always, we implement minimal error and edge case handling – definitely not production-ready. ;-)

Having said all that, let’s start with modifications to our Main class. Since the name SpringApplication is already reserved, and summer follows on spring, let’s call it … SummerApplication:

1import com.mlesniak.boot.SummerApplication;
2
3public class Main {
4    public static void main(String... args) {
5        SummerApplication.run(Main.class, args);
6    }
7}

The remaining files stay the same, though, as promised, we change the imports:

 1// MessageProvider.java
 2import com.mlesniak.boot.Component;
 3
 4@Component
 5public class MessageProvider {
 6    public String getMessage() {
 7        return "Hello, world";
 8    }
 9}
10
11// MessageConsumer.java
12import com.mlesniak.boot.CommandLineRunner;
13import com.mlesniak.boot.Component;
14
15@Component
16public class MessageConsumer implements CommandLineRunner {
17  private final MessageProvider messageProvider;
18
19  public MessageConsumer(MessageProvider messageProvider) {
20    this.messageProvider = messageProvider;
21  }
22
23  @Override
24  public void run(String... args) {
25    String message = messageProvider.getMessage();
26    System.out.println(message);
27  }
28}

Marking things…

Since we do not use Controllers but still want an entrypoint, let’s define our own marker interface:

1package com.mlesniak.boot;
2
3/// Marker interface to determine where our application
4/// starts since we do not have typical controllers
5/// waiting for HTTP requests.
6public interface CommandLineRunner {
7    void run(String... args);
8}

We also want to annotate service classes with our own Component annotation

 1package com.mlesniak.boot;
 2
 3import java.lang.annotation.ElementType;
 4import java.lang.annotation.Retention;
 5import java.lang.annotation.RetentionPolicy;
 6import java.lang.annotation.Target;
 7
 8///
 9/// Marker interface to determine components of our application.
10///
11/// For every class marked as a component, we try to resolve all
12/// dependencies in its constructor.
13@Retention(RetentionPolicy.RUNTIME)
14@Target(ElementType.TYPE)
15public @interface Component {
16}

The interesting part

The actual magic is implemented in the following 140 lines of code. We walk through them step by step.

 1package com.mlesniak.boot;
 2
 3import com.mlesniak.Main;
 4
 5import java.io.IOException;
 6import java.lang.reflect.InvocationTargetException;
 7import java.net.URI;
 8import java.net.URISyntaxException;
 9import java.nio.file.*;
10import java.util.*;
11import java.util.stream.Collectors;
12
13/// Core dependency injection resolution.
14public class SummerApplication {
15  // ... to be filled out in this section ...
16}

Our sole public method is run, which serves to purposes:

1. Create all necessary singletons
2. Figure out the component implementing CommandLineRunner and start them.

Therefore, the code is straightforward:

 1  /// Entry point into dependency injection.
 2  ///
 3  /// @param mainClass The main class of the application, ideally placed at the root package.
 4  /// @param args      Command line args.
 5  public static void run(Class<Main> mainClass, String[] args) {
 6      List<Class<?>> components = getComponents(mainClass);
 7
 8      // For our example, we support only singletons.
 9      Map<Class<?>, Object> instances = new HashMap<>();
10      components.forEach(component -> createSingleton(instances, new HashSet<>(), component));
11
12      // Find entry point by looking for the class implementing CommandLineRunner. 
13      var entryClasses = instances
14              .keySet().stream()
15              .filter(SummerApplication::hasCommandLineRunnerInterface)
16              .toList();
17      if (entryClasses.isEmpty()) {
18          throw new IllegalStateException("No entry point defined via CommandLineRunner");
19      }
20      if (entryClasses.size() > 1) {
21          throw new IllegalStateException("Ambiguous entry points defined via CommandLineRunner");
22      }
23      var entryClass = entryClasses.getFirst();
24
25      ((CommandLineRunner) instances.get(entryClass)).run(args);
26  }
27
28  private static boolean hasCommandLineRunnerInterface(Class<?> clazz) {
29    return Arrays.stream(clazz.getInterfaces())
30            .anyMatch(i -> i == CommandLineRunner.class);
31  }

A key function is getComponents. We need to collect all classes annotated with our custom component annotation on the classpath:

 1  /// Get a list of all components based on the passed package of the class.
 2  ///
 3  /// @param mainClass the root class to start scanning.
 4  private static List<Class<?>> getComponents(Class<Main> mainClass) {
 5      try {
 6          return findAllClassesInPackage(mainClass.getPackageName()).stream()
 7                  .filter(c -> c.getAnnotation(Component.class) != null)
 8                  .collect(Collectors.toList());
 9      } catch (IOException | URISyntaxException e) {
10          throw new IllegalStateException("Error retrieving components, starting at " + mainClass.getSimpleName(), e);
11      }
12  }

This is slightly complicated since we can either run our application with an unpacked classpath, e.g. on the command line or via an IDE, or as a packed (fat) . jar-file.

Thanks to the abstraction provided by java.nio, this can be handled quite elegantly:

 1  /// Retrieve a list of all classes in a package (or its children). This method supports both unpacked
 2  /// (target/classes) and packed (.jar) class containers.
 3  private static Set<Class<?>> findAllClassesInPackage(String packageName) throws IOException, URISyntaxException {
 4      String path = packageName.replace('.', '/');
 5      URI uri = SummerApplication.class.getResource("/" + path).toURI();
 6
 7      if (uri.getScheme().equals("jar")) {
 8          // We have to create a "virtual" filesystem to access the class files stored in the
 9          // .jar file.
10          try (FileSystem fileSystem = FileSystems.newFileSystem(uri, Collections.emptyMap())) {
11              return findClassesInPath(fileSystem.getPath(path), packageName);
12          }
13      }
14
15      // We're running the injection code from an unpacked archive and can directly access the .class files.
16      return findClassesInPath(Paths.get(uri), packageName);
17  }

Therefore, when looking for classes in findClassesInPath, we do not care if we walk through the archived files of the .jar or are actually looking on real files on our filesystem. Retrieving the actual class definitions consists now of just

 1  /// Iterate through all .class files in the given path for the given package.
 2  private static Set<Class<?>> findClassesInPath(Path path, String packageName) throws IOException {
 3      try (var walk = Files.walk(path, 1)) {
 4          return walk
 5                  .filter(p -> !Files.isDirectory(p))
 6                  .filter(p -> p.toString().endsWith(".class"))
 7                  .map(p -> getClass(p, packageName))
 8                  .filter(Objects::nonNull)
 9                  .collect(Collectors.toSet());
10      }
11  }
12
13  /// Retrieve a class based on the path and package name.
14  private static Class<?> getClass(Path classPath, String packageName) {
15      try {
16          String className = packageName + "." + classPath.getFileName().toString().replace(".class", "");
17          return Class.forName(className);
18      } catch (ClassNotFoundException e) {
19          return null;
20      }
21  }

I know that we do not recursively descend into subdirectories – good enough for the example ;-).

Once we have a list of class definitions, we can finally instantiate them and call component constructors with the instantiated classes. The dependency resolution and object instantiation happens in createSingleton. To simplify our implementation, we have a very basic dependency resolution. This function is called recursively for all constructor arguments to find singleton instances. If they are not yet available, we try to construct them while resolving their dependencies as well. To keep track of cycles, we keep track of already visited classes.

This could of course be done more clever for the price of blowing up the number of lines of code, hence, good enough for this demonstration.

 1  /// Creates a new instance for the passed class using its constructor.
 2  ///
 3  /// We resolve all dependent constructor parameters.
 4  private static void createSingleton(Map<Class<?>, Object> singletons, Set<Class<?>> visited, Class<?> clazz) {
 5      // Cycle detection. We've been called to resolve a parameter dependency, but already tried to resolve the
 6      // dependencies for this class. When trying to resolve clazz' dependencies, we will run into an infinite cycle.
 7      if (!visited.add(clazz)) {
 8          var names = visited.stream().map(Class::getSimpleName).collect(Collectors.joining(", "));
 9          throw new IllegalStateException("Cycle detected. Visited classes=" + names);
10      }
11      var cs = clazz.getDeclaredConstructors();
12      if (cs.length > 1) {
13          throw new IllegalArgumentException("No unique constructor found for " + clazz.getSimpleName());
14      }
15
16      var constructor = cs[0];
17      var expectedInjections = constructor.getParameterTypes();
18
19      // For every dependent dependency, generate a new instance. Note that we implicitly handle the case for
20      // parameter-less constructors here as well.
21      Arrays.stream(expectedInjections).forEach(depClass -> {
22          createSingleton(singletons, visited, depClass);
23      });
24
25      var params = Arrays.stream(expectedInjections).map(singletons::get).toArray();
26      try {
27          singletons.put(clazz, constructor.newInstance(params));
28      } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
29          throw new IllegalStateException("Unable to create instance for " + clazz.getSimpleName(), e);
30      }
31  }

Conclusion

… and well, that’s actually all you need to implement. As stated above, it’s far from complete or error-prone. The important thing, though, is: dependency injection is not some magical thing that happens behind the curtains of famous and advanced frameworks. Instead, it’s something that you could have invented yourself.

Source code

The whole source code can be found on GitHub.

In modern web applications, real-time communication is more important than ever. Features like live updates, collaborative editing, notifications, and data streaming have become standard expectations for users. Before we look at Server-Sent Events, let’s first look at a few alternatives.

Alternatives to SSE

Polling

Polling is the simplest approach to achieve near-real-time updates. The client repeatedly sends HTTP requests to the server at regular intervals to check for changes. While easy to implement, this method is inefficient. It generates unnecessary network traffic and puts extra load on the server, especially when updates are infrequent. The client may poll repeatedly even when no updates are available, resulting in wasted resources.

Long Polling

Long polling improves upon basic polling by keeping the HTTP connection open until the server has an update to send. Once the server responds with data, the connection closes, and the client immediately reopens it to wait for the next update. While this reduces some of the inefficiencies of traditional polling, it still has drawbacks. Opening and closing connections repeatedly can strain resources, and implementing long polling often introduces additional complexity.

WebSockets

WebSockets offer full-duplex communication, enabling the server and client to send messages to each other in real time. While this is powerful, WebSockets can be overkill for many use cases that only require one-way communication from the server to the client. They also add complexity in terms of setup, management, and maintaining stateful connections, which can be challenging in distributed or load-balanced environments.

Why SSE?

SSE provide a lightweight, efficient, and straightforward way for servers to push updates to clients. They rely on a simple HTTP connection, making them easy to implement and compatible with most environments. Unlike WebSockets, SSE is inherently one-directional (server to client), which is ideal for scenarios like live score updates, stock price monitoring, or streaming logs.

With SSE, developers get a solution that’s simple to use, resource-friendly, and aligned with the natural statelessness of HTTP. In many cases, it’s the elegant middle ground between the brute force of polling and the power of WebSockets.

Backend with Spring Boot

The backend streams Server-Sent Events (SSE) using Spring Boot’s SseEmitter class. In general, this should be quite straightforward. We expose an endpoint via /events with an optional count to restrict the number of sent events. Once a client (which supports SSE) connects, we emit JSON-serialized tick events with a unique id and event name.

In a classic REST-based API, one can add this as an extension to the query endpoints. Besides GET /users and GET /users/{id} you would also have GET /users/events and GET /users/{id}/events.

Implementation

 1record Tick(int tick) { }
 2
 3@RestController
 4public class EventController {
 5    private static final Logger log = LoggerFactory.getLogger(EventController.class);
 6    private final ObjectMapper objectMapper;
 7
 8    public EventController(ObjectMapper objectMapper) {
 9        this.objectMapper = objectMapper;
10    }
11
12    @GetMapping("/events")
13    public SseEmitter events(@RequestParam(name = "count", required = false) Integer count) {
14        var max = count == null ? 10 : count;
15        log.info("/events called with count {} and max {}", count, max);
16
17        var emitter = new SseEmitter(60 * 1000L);
18        var id = UUID.randomUUID().toString();
19        Executors.newSingleThreadScheduledExecutor().execute(() -> {
20            try {
21                for (int i = 0; i < max; i++) {
22                    var tick = new Tick(i);
23                    emitter.send(SseEmitter.event()
24                            .name("tick")
25                            .id(id)
26                            .data(objectMapper.writeValueAsString(tick)));
27                    TimeUnit.MILLISECONDS.sleep(500);
28                }
29                // Without a payload, the event is not correctly processed
30                // in the browser. This is actually expected behaviour,
31                // see https://github.com/denoland/deno/issues/23135.
32                emitter.send(SseEmitter.event().name("close").data(""));
33                log.info("Closing connection");
34                emitter.complete();
35            } catch (Exception e) {
36                emitter.completeWithError(e);
37            }
38        });
39
40        return emitter;
41    }
42}

The only annoying trap was figuring out why the close event was never processed by the frontend (see below). If you omit any data, the browser is free to ignore the event…

Testing the endpoint with curl

When using curl, this looks like

 1$ curl http://localhost:9000/events?count=4
 2event:tick
 3id:ba711ed1-bb55-4696-9312-ca4c10725e5a
 4data:{"tick":0}
 5
 6event:tick
 7id:ba711ed1-bb55-4696-9312-ca4c10725e5a
 8data:{"tick":1}
 9
10event:tick
11id:ba711ed1-bb55-4696-9312-ca4c10725e5a
12data:{"tick":2}
13
14event:tick
15id:ba711ed1-bb55-4696-9312-ca4c10725e5a
16data:{"tick":3}
17
18event:close
19data:

A simple user interface

By any means, I am not a frontend software engineer. Nonetheless, here’s a basic, framework-less UI which shows how to use SSE in a client. The key implementation is this JavaScript snippet

 1document.querySelector('form').addEventListener('submit', e => {
 2    e.preventDefault();
 3    const count = document.getElementById('count').value;
 4    document.getElementById('count').value = '';
 5    const eventDisplay = document.getElementById('events');
 6    eventDisplay.innerHTML = '';
 7
 8    if (window.eventSource) window.eventSource.close();
 9    window.eventSource = new EventSource(`/events?count=${count}`);
10
11    eventSource.addEventListener('tick', event => {
12        const p = document.createElement('p');
13        p.textContent = `Tick: ${JSON.parse(event.data).tick + 1}`;
14        eventDisplay.appendChild(p);
15    });
16
17    eventSource.addEventListener('close', () => eventSource.close());
18});

Once we’ve subscribed to the submit event of the form, we use the Browser’s EventSource API to listen to events sent by the server and react accordingly.

If we do not react to a close event by closing our listener, and the server closes its connection on their side, the browser will simply reopen the connection after a few seconds and listen to new events again.

The specification

Server-Sent Events (SSE) are defined as part of the HTML5 specification. They provide a standardized way for servers to push updates to web clients over a persistent HTTP connection using a lightweight, text-based protocol.

Key Characteristics

1. Protocol:

   • SSE uses a standard HTTP connection (typically GET requests).
   • The Content-Type for SSE responses must be text/event-stream.
   • HTTP headers like Cache-Control: no-cache are commonly used to prevent caching of the event stream by intermediaries.
   • Connections are usually kept open indefinitely, relying on persistent HTTP/1.1 or HTTP/2 features.

2. Event Format:

   • Events are sent as plain text in the following structure:

     id: <unique-id>
     event: <event-name>
     data: <payload>

   • Each event ends with a blank line to indicate completion.
   • Binary data is not directly supported, i.e., must be encoded with Base64.

3. Auto-Reconnection:

   • If the connection is lost, the browser automatically attempts to reconnect after a short delay.
   • The id field allows clients to resume from the last event by sending a Last-Event-ID header in subsequent requests.

4. Character Encoding:

   • SSE requires UTF-8 encoding for all transmitted data.

An exchange with curl

Coming back to our example with curl, we can verify the actual HTTP headers sent in the response.

 1$ curl -v http://localhost:9000/events?count=4
 2* Host localhost:9000 was resolved.
 3* IPv6: ::1
 4* IPv4: 127.0.0.1
 5*   Trying [::1]:9000...
 6* Connected to localhost (::1) port 9000
 7> GET /events?count=4 HTTP/1.1
 8> Host: localhost:9000
 9> User-Agent: curl/8.9.1
10> Accept: */*
11>
12* Request completely sent off
13< HTTP/1.1 200
14< Content-Type: text/event-stream
15< Transfer-Encoding: chunked
16< Date: Sat, 21 Dec 2024 17:32:27 GMT
17<
18event:tick
19id:5d482700-187c-4928-8de5-cca0681f0aac
20data:{"tick":0}

A backend using just the JDK

Looks like Server-Sent Events are not magic at all. While Spring allows us to use them via a comfortable API through the SseEmitter class, we can easily write our own backend implementation – the frontend part is left as an exercise for the reader.

For convinience, we also left out handling of the optional count parameter since it’s not relevant for the protocol and the thread handling. It’s easy to add but would hide the relevant part, the implementation of SSE itself.

 1// ...boring package declaration and imports...
 2
 3record TickEvent(int tick) {
 4   String toJson() {
 5      return "{\"tick\":" + tick + "}";
 6   }
 7}
 8
 9record SseEvent(String id, String event, String data) {
10   String toSseFormat() {
11      // Not beautiful, but good enough.
12      return "id: " + id + "\n" +
13              "event: " + event + "\n" +
14              "data: " + data + "\n\n";
15   }
16}
17
18public class SseServer {
19   public static void main(String[] args) throws Exception {
20      // Create a basic HTTP server which is part of the JDK.
21      HttpServer server = HttpServer.create(new InetSocketAddress(9000), 0);
22      server.createContext("/events", new SseHandler());
23      server.setExecutor(Executors.newCachedThreadPool());
24      server.start();
25   }
26
27   static class SseHandler implements HttpHandler {
28      private final ObjectMapper objectMapper = new ObjectMapper();
29
30      @Override
31      public void handle(HttpExchange exchange) {
32         try {
33            // Set default headers for SSE.
34            exchange.getResponseHeaders().set("Content-Type", "text/event-stream");
35            exchange.getResponseHeaders().set("Cache-Control", "no-cache");
36            exchange.getResponseHeaders().set("Connection", "keep-alive");
37            exchange.sendResponseHeaders(200, 0);
38
39            try (OutputStream os = exchange.getResponseBody()) {
40               var id = UUID.randomUUID().toString();
41               for (int i = 0; i < 10; i++) {
42                  TickEvent tickEvent = new TickEvent(i);
43                  SseEvent sseEvent = new SseEvent(
44                          id,
45                          "tick",
46                          tickEvent.toJson()
47                  );
48
49                  os.write(sseEvent.toSseFormat().getBytes());
50                  os.flush();
51                  Thread.sleep(500);
52               }
53
54               SseEvent closeEvent = new SseEvent("", "close", "");
55               os.write(closeEvent.toSseFormat().getBytes());
56               os.flush();
57            }
58         } catch (Exception e) {
59            // 🙈 ... good enough for us.
60            e.printStackTrace();
61         }
62      }
63   }
64}

Source code

The whole source code can be found on GitHub.

Dr. Michael Lesniak
Joseph-König-Str. 8
48147 Münster

Contact options

Email: mail@mlesniak.com
LinkedIn: Link to my profile
Phone: +49 151 551 69 221

Company details

VAT identification number: DE366616834

Responsible for content

Responsible for content pursuant to § 18 (2) MStV: Dr. Michael Lesniak, Joseph-König-Str. 8, 48147 Münster

Liability and Intellectual Property Rights Information

Liability Disclaimer: While the content of this website has been put together with great care and reflects our current knowledge, it is provided for information purposes without being legally binding, unless the disclosure of this information is required by law (e.g. the legal information, the privacy policy, terms and conditions or mandatory instructions for consumers). We reserve the right to modify or delete the content, whether in full or in part, provided this does not affect our existing contractual obligations. All website content is subject to change and non-binding.

Link Disclaimer: We do not accept any responsibility for or endorse the content of external websites we link to, whether directly or indirectly. The providers of the linked websites are solely responsible for all content presented on their websites and in particular, any damage resulting from the use of the information offered on their websites.

Copyrights and Trademarks: All contents presented on this website, such as texts, photographs, graphics, brands and trademarks are protected by the respective intellectual property rights (copyrights, trademark rights). The use, reproduction, etc. are subject to our rights or the rights of the respective authors or rights owners.

Information on legal infringements: Please notify us if you notice any rights violations on our website. Once notified, we will promptly remove any illegal content or links.

Privacy Policy

Controller — Personal data on this website is processed by the provider named above (see “Provider”).

Hosting — This website is hosted on our own server. The underlying infrastructure (data center and physical server) is provided by Hetzner Online GmbH, Industriestr. 25, 91710 Gunzenhausen, Germany. The server is located in Germany (EU). The web server does not keep access logs: no IP addresses or request data are written to log files. Your IP address is processed transiently by the server and network stack only to deliver the requested pages, based on our legitimate interest in operating the site securely (Art. 6(1)(f) GDPR). An order-processing agreement (AVV, Art. 28 GDPR) is in place with the infrastructure provider.

Contacting us — If you contact us by email, the data you provide is processed solely to handle your enquiry (Art. 6(1)(b)/(f) GDPR) and deleted once it is resolved, subject to statutory retention periods.

External links — This site links to third-party services (Calendly, LinkedIn, Lichess). No data is sent to them when you load this site — only once you click a link and leave. Their own privacy policies then apply; Calendly in particular is US-based.

Your rights — You have the rights to access (Art. 15), rectification (Art. 16), erasure (Art. 17), restriction (Art. 18), data portability (Art. 20), and objection (Art. 21). Where processing relies on consent, you may withdraw it at any time. You may also lodge a complaint with a supervisory authority; the one responsible for our location is the LDI NRW (Landesbeauftragte für Datenschutz und Informationsfreiheit Nordrhein-Westfalen).

Encryption — All connections to this site use TLS/SSL.

As of June 2026.

I started coding on a C64 and achieved a lot since then.

Leading teams. Designing systems. Solving tough bugs. Earning promotions.

But I felt empty.

Even though my CV looked impressive, I didn’t feel connected to what I loved.

Getting my hands dirty, solving real problems that make a difference for customers.

To bring back the spark and make my younger self proud again, I moved to freelancing.

I build impactful features — from understanding the goal, to architecture, implementation, and rollout.

The spark returned.

My younger self is proud again, though would have a lot to say about my lack of gaming skills.

I want my work to matter.

That’s why I focus on startups and small businesses.

They don’t need consulting, they need to move fast.

They need someone who delivers immediate value.

That’s where I excel.

What’s in it for you?

I improve your architecture to handle 10x the data, build a time-critical feature to close a big deal, or fix a framework bug which blocks a critical security upgrade.

I don’t just offer advice.

I’m in the code with your team.

I build what helps you scale and succeed.

Yet, I’m not the right fit for every company.

Don’t reach out if you’re

• looking for consultants rather than doers.

• not ready for rapid, hands-on problem-solving.

• preferring slow processes over fast, effective execution.

Ready for someone who doesn’t just write code but crafts solutions that resonate with your mission … and has a talent for confusing, but funny, metaphors?

Shoot me a message. I’ll respond in <10ms.

Qualifications

Expert

Java, Kotlin, Spring Boot, Docker, Cloud (AWS), Terraform, Git, SQL, Software architecture, Distributed systems, Microservices, API Design, REST, Scrum, Code Reviews, Refactoring, Requirements Engineering, Implementation, Debugging, Analytical thinking, Leadership, Mentoring and coaching

Professional

Linux, Domain-Driven Design, Serverless, MongoDB, Cassandra, Neo4J, PostgreSQL, RAG, LLM, Claude Code, Project management, Testing, Implementation and analysis of algorithms, Atlassian products (JIRA, Confluence)

Basic

Go, JavaScript, TypeScript, Python, React, Angular, gRPC, Cloud (Azure, GCP), MCP

Languages

• German: native speaker
• English: professional proficiency

Certifications

• 05/2026 AWS Certified AI Practitioner
• 05/2026 Generative AI with Large Language Models
• 09/2024 AWS Certified Solution Architect Associate
• 11/2023 HashiCorp Certified: Terraform Associate (003)
• 03/2021 AWS Certified Cloud Practitioner
• 02/2019 – 04/2021 Training as a Systemic Coach (SG)
  • Supported and guided individuals and teams in developing solutions and overcoming conflicts through systemic interventions
  • Assisted with change processes for teams and organizations to enable smooth transitions and effective adaptation
• 10/2018 Certified Neo4J Professional
• 03/2017 Scrum Professional Scrum Master (ITEMO)
• 11/2014 MapR Certified Hadoop Professional: Developer (MCHP:D)
• 02/2013 Certified Professional for Requirements Engineering Foundation Level

Project list

04/2026 | Technical Advisor

MACH

• Advised on technical architecture and platform strategy for an early-stage business initiative
• Evaluated infrastructure options, cost structures, and scalability tradeoffs
• Contributed to product and system design decisions during the concept phase

10/2025 – 04/2026 | Senior Java Software Engineer

Micromerce

• Built and evolved a data lake to centralize data processing, analytics, and long-term storage, improving data transparency and enabling better business decisions
• Designed and implemented an S3-based backup and archiving strategy, increasing data reliability while significantly optimizing storage costs through lifecycle management
• Developed a comprehensive data deletion and retention concept, ensuring GDPR-compliant data handling and reducing operational and legal risks
• Delivered targeted performance and cost optimizations, reducing execution times, infrastructure costs, and system load while improving overall stability
• Analyzed and resolved production issues and bottlenecks, leading to increased system reliability and availability
• Established scalable data processing and background job workflows to handle large data volumes efficiently
• Improved monitoring, logging, and alerting, enabling faster incident detection and reduced downtime
• Enhanced deployment and quality assurance processes, increasing release reliability and development efficiency

Keywords: Java (17, 21), AWS, SQS, DynamoDB, Microservices, CDK, TypeScript

12/2024 – 09/2025 | Senior Software Engineer

Milia

• Enabled fulltext search by designing an OpenSearch (ElasticSearch)-based solution and incorporating business-specific rules
• Improved client responsiveness by designing and implementing an adaptive invitation reminder subsystem
• Improved client experience and reduced support team load by analyzing, designing, implementing, and maintaining a DATEV document status replication system
• Improved platform scalability by designing and re-implementing synchronous processes as asynchronous
• Analyzed and fixed bugs in close collaboration with the support team
• Improved the CI/CD GitHub-based build pipeline
• Designed and implemented business-specific features

Keywords: Java, AWS, SQS, Postgresql, Microservices, DATEV

02/2024 – 08/2024 | Senior Java Software Engineer

Micromerce

• Improved ticket processing time by connecting the ticket system to the OpenAI API
• Enhanced AI responses by setting up and configuring a RAG-based system
• Reduced database costs in DynamoDB by over 30% through improvements to the company-specific persistence framework
• Enabled teams to work faster by adding JavaScript support alongside Groovy in the in-house scripting engine
• Made solutions engineers more productive by developing a custom VSCode extension supporting an internal configuration language with validation and auto-completion
• Improved platform stability by analyzing and fixing SQS performance issues
• Future-proofed the infrastructure-as-code setup by adopting CDK for AWS and migrating the existing codebase from an unsupported legacy solution
• Improved platform security by implementing a custom brute-force prevention mechanism
• Helped teams evaluate tradeoffs of different architectural approaches

Keywords: Java (17, 21), AWS, SQS, DynamoDB, Microservices, CDK, TypeScript

01/2024 - 02/2024 | Consultant

AlgoMinds GmbH

• Implemented a complete CI pipeline (including supporting systems such as build pools) from scratch via Infrastructure as Code on Azure

Keywords: Infrastructure as Code, Pulumi, Microsoft Azure, C#, .NET Core 8, TypeScript

04/2021 – 11/2023 | Principal Engineer

Scalable Capital GmbH

• Planned, led, and implemented a large-scale migration of a mission-critical retail investment platform (400k+ lines of code) from Spring Boot 2.3 to 3.1
• Designed and prototyped refactoring approaches from a monolithic to a distributed service-oriented architecture
• Defined and introduced company-wide standards and best practices including Architectural Decision Records, code review processes, and service templates
• Planned, designed, coordinated, and implemented business-critical product features
• Drove company-wide technical decisions and architectural designs, adopted across engineering leadership

Keywords: Kotlin, Java, Go, Python, Terraform, SQL and NoSQL, Jenkins, CI/CD, AWS (EC2, ECS, RDS, Aurora, Lambda, DynamoDB etc.), Serverless, Microservices, Distributed, fault-tolerant and scalable architecture, Large-scale refactoring

10/2020 - 03/2021 | Platform Engineer

AirMap

• Designed, implemented, and maintained a nationally deployed registry for drone operators
• Coordinated an international development team across the USA, Argentina, and Germany
• Improved software development processes
• Extended and improved the underlying AirMap platform
• Conducted code reviews

Keywords: Go, Python, Postgres, AWS, Kubernetes

02/2020 – 10/2020 | CTO

fino GmbH

• Managed and provided technical and disciplinary oversight to a team of more than twenty employees
• Developed an API-first strategy encompassing software architecture, business processes, product strategy, and employee training
• Analyzed and improved a microservice-based distributed architecture
• Mentored and coached software developers, team leads, and product owners
• Facilitated Scrum processes and conducted training for development teams
• Coordinated recruitment and selection of nearshore and offshore freelancers and teams

Keywords: Go, Java, Python, TypeScript, MongoDB, Elastic Stack, Sematext, Kubernetes, OTC (Open Telecom Cloud), CQRS

07/2012 – 01/2020 | Software Architect

Micromata GmbH

• Progressed from Software Engineer to Software Architect across 7+ years; led teams, coached engineers, served as Scrum Master
• Applications & platforms: worldwide IAM system; KPI management platform (finance); fail-safe logistics application; route planning and dispatch system; package label sorting system; pharmaceutical sector application; SAP cloud platform applications; logistics performance troubleshooting
• Data & analytics: enterprise analytics data lake; predictive maintenance platform (ML on industrial time series); Hadoop-based enterprise reporting platform; Big Data architecture (BMBF-funded research); personal data pseudonymization tool

Keywords: Java, Spring Boot, Docker, AWS, Elasticsearch, Neo4j, PostgreSQL, Scala, Spark, Hadoop, React

2015 – 2019 | Lecturer for Web-Engineering

University of Kassel

• Planned and conducted the master’s lecture “Web Engineering”
• Topics: Modern web architectures, frontend and backend development, deployment on cloud platforms, software tooling
• Supervised project groups
• Provided examination feedback and grading

04/2008 – 04/2012 | Fixed-term Research Associate

University of Kassel

• Planned, executed, and analyzed research projects in functional programming languages and parallel programming
• Published research results
• Presented at international conferences
• Lectured on functional programming languages and foundational courses
• Supervised student research assistants
• Guided student project and thesis work

08/2007 – 12/2007 | Fixed-term Research Associate

DCAITI / TU Berlin

• Planned and executed research projects
• Investigated and developed multimodal human-machine software architectures
• Conceptualized situation-based and adaptive learning mechanisms

Education

04/2008 - 04/2012 | Ph.D. in Computer Science

University of Kassel

• Title: “On the Benefits of Abstraction in Concurrent Haskell”
• Focused on advancing the field of functional programming and concurrency models.

10/2001 - 06/2007 | Diploma in Computer Science with a minor in Mathematics

Technical University of Clausthal

• Comparable to a Master’s degree.
• Comprehensive curriculum covering both theoretical and applied aspects of computer science and mathematics.

Jonas Danker, CTO

Micromerce GmbH — September 2024

Vincent Sommer, Head of Engineering

milia.io — October 2025

Christian Dymek, Founder

MACH — April 2026

Recommendations from my time as a former permanent employee, in roles ranging from Engineer to CTO (more on LinkedIn):

Andreas Schranzhofer, CTO

Scalable Capital — October 2024

Johannes Weiss, VP Engineering

Scalable Capital — October 2024

Aleksandar Jeremic, CEO

fino digital — October 2024

Dominik Goby, Senior Application Architect

Amazon Web Services — October 2024

Gabriel Pavlovic, Product Lead

Scalable Capital — October 2024

Shady Botros, Senior Software Engineer

Wolt (DoorDash) — October 2024

Alexander-Nikolai Gomes, DevOps/MLOps Engineer

TECLION — October 2024