Senior Software Engineer (f/m/d)

This role is suited for a Senior Software Engineer who enjoys deep backend and system design work and has experience owning complex, long-lived production systems. It fits engineers comfortable designing stable APIs, cache-aware execution pipelines, and data models, while also working across layers to build tooling or simple UIs when needed. The ideal candidate is product-minded, confident operating in ambiguity, and motivated by building foundational platforms for dynamic content, personalization, and future AI-driven experiences.

1. What interests you about this role and Contentful’s new dynamic content initiative?
   I like that this role focuses on the core engine that powers dynamic content, personalization, and AI-assisted experiences. I’ve worked a lot with content-heavy applications and delivery APIs, so the idea of designing the underlying resolution and delivery systems that many teams and customers will depend on is very appealing.

2. Describe your experience owning complex, long-lived production systems.
   I’ve owned several services from design through production support: defining data models and APIs, setting up observability, handling on-call incidents, and iterating safely over years. That’s included schema evolution, backward-compatible changes, performance tuning under increasing load, and refactoring without breaking downstream consumers.

3. How do you approach designing backend systems for correctness and maintainability?
   I start with clear domain modeling and explicit contracts: well-defined types, schemas, and invariants. I favor simple data flows, idempotent operations, and deterministic behavior. For maintainability, I invest in modular boundaries, comprehensive tests, automated checks, and documentation that explains not just “how” but “why” the system works as it does.

4. What is your experience designing and evolving APIs and data models used by other teams or customers?
   I’ve designed public APIs and shared schemas that multiple teams depend on. I focus on stable contracts, clear naming, and versioning strategies (e.g., additive changes, deprecation policies, and occasionally versioned endpoints or schemas). I also provide good examples and documentation so integrators can use them correctly and confidently.

5. How would you design a cache-aware execution pipeline for dynamic content delivery?
   I’d separate the pipeline into clear stages—fetch, resolve, transform, and shape—while making each stage explicit about its inputs and cache keys. I’d rely on immutable inputs, deterministic outputs, and structured cache metadata so we can safely reuse computations, invalidate selectively, and measure hit/miss rates. Observability is key to validate cache behavior in production.

6. How do you ensure performance guarantees for content resolution at scale?
   I’d start by defining clear SLAs/SLOs, then design for bounded work per request: limiting fan-out, avoiding unbounded joins, and precomputing or indexing expensive lookups. I’d use profiling, load testing, and real-time metrics to identify bottlenecks, and apply techniques like caching, batching, and asynchronous precomputation where appropriate.

7. What experience do you have with declarative systems or data transformation pipelines?
   I’ve worked with systems where users configure rules or mappings that the engine executes declaratively—for example, mapping content types to presentation variants, or building ETL-like pipelines for transforming and filtering data. I focus on making the execution model predictable, debuggable, and explainable so users can understand why a particular output was produced.

8. How do you approach building tooling and UIs for debugging and explaining system behavior?
   I like to expose the internal pipeline as a series of steps with inputs, outputs, and timings. A good UI lets users see how a request was resolved, what rules fired, where caching applied, and where failures or fallbacks occurred. I pair that with structured logs, traces, and correlation IDs so engineers can drill down from UI views into raw telemetry if needed.

9. How do you handle ambiguity and make architectural tradeoffs in early-stage foundational work?
   I clarify the core invariants and long-term constraints, then design for extension rather than prediction. I start with small, composable primitives and evolve them based on real usage and feedback. When making tradeoffs, I weigh correctness, simplicity, and operability over premature optimization, but I avoid choices that would be very costly to change later (e.g., core data model mistakes).

10. How do you collaborate with product and other engineering teams on integration and UX?
    I involve product and partner teams early: co-defining use cases, constraints, and success metrics. On the engineering side, I provide well-documented APIs, reference implementations, and demo experiences so integration is smooth. I also keep feedback loops tight—regular check-ins, RFCs, and design reviews—to ensure the platform capabilities align with the real UX and content authoring needs.

Contentful is hiring Senior Software Engineers (Berlin, hybrid/remote within Germany) to design and own core backend systems that power dynamic content resolution, personalization, and future AI-assisted experiences across channels. You’ll architect deterministic, cache-aware execution pipelines, define APIs and data models used by other teams and customers, and build lightweight UIs and tooling to preview, debug, and explain system behavior. This role is ideal if you love complex, long-lived distributed systems, enjoy working across backend and UI layers, and want your work to directly shape how thousands of brands deliver content at scale. Contentful offers stock options, comprehensive health coverage, generous time off and learning budgets, wellbeing stipends, and the chance to work with a diverse, global team redefining digital experience platforms.