Software engineer · Amsterdam

Engineering the systems behind product growth.

I turn complex product and platform problems into clear, reliable experiences—from onboarding and lifecycle communication to monetization, APIs, and data systems.

Currently building Neon and Lakebase at Databricks, after Neon's acquisition.

Product engineering, end to end.

I work across customer-facing growth, product infrastructure, and the systems that connect them—taking ideas from early framing through production operation.

Now

Databricks

Software Engineer · Neon & Lakebase

Continuing the Neon product inside Databricks

Growth and product engineering for the Neon product and Lakebase inside Databricks. I work across lifecycle experiences, onboarding, monetization, and the platform services that support them.

  • Growth engineering
  • Neon product
  • Lakebase
Previously

Neon

Software Engineer · Growth & Console

Acquired by Databricks

Built customer-facing experiences and shared growth systems across the Console and platform, including lifecycle communication, access control, billing safeguards, partner integrations, and frontend foundations.

  • Lifecycle systems
  • React & TypeScript
  • Go & PostgreSQL
Earlier

Independent & early-stage teams

Full-stack Engineer

Healthcare, developer tooling and B2B software

Built web and mobile products for teams working in healthcare, customer operations, technology evaluation, forms and analytics, and municipal services.

  • Web applications
  • Mobile products
  • Cloud services

How I approach engineering

A few principles I return to when the problem is ambiguous, crosses several layers of the stack, or needs to move safely into production.

01/ 01

Start with the model

Before choosing components or endpoints, I try to understand the entities, boundaries, states, and failure modes. A clear model usually makes the implementation simpler.

02/ 02

Keep product and systems close

I like working across the interface and the service behind it. Decisions in one layer are often easier when the constraints of the other are visible.

03/ 03

Design the rollout, not only the feature

Migrations, observability, rollback paths, and operational ownership are part of the design. Shipping safely matters as much as reaching code complete.

04/ 04

Measure beyond launch

For growth work, delivery is the start. I instrument funnels, watch product behavior and reliability, and use production evidence to decide what to improve next.

Systems designed for real product constraints.

Selected work across lifecycle growth, monetization, product experience, and platform engineering. Each case study focuses on the problem, my contribution, and the tradeoffs that shaped the system.

Neon · 04 systems
Case study / 01Neon

Event-driven notification platform

The system

Shared infrastructure that turns product and operational events into useful, timely customer communication.

My contribution

Designed and operated the event model, delivery path, deduplication, campaign workflow, monitoring, and reliability improvements.

Engineering considerations

GoRedisPostgreSQLDatabricks
Technical case study / 01

Designing reliability into lifecycle communication

Representative architecture

The engineering problem

Customer communication looks simple at the interface. Underneath, it is a distributed-systems problem: events repeat, downstream providers fail, campaigns change, and operators still need to explain what happened.

My scope

  • Event model and processing boundaries
  • Deduplication and delivery behavior
  • Campaign workflow and operational tooling
  • Monitoring and reliability improvements

Outcome

A shared foundation for product and operational communication, with reliability behavior designed into the platform path rather than recreated for each campaign.

Architecture

Boundaries before components

01

Product intent

Stable event model

A product or operational event describes what happened—not how a message should be delivered.

02

Safe processing

Retry-safe boundary

Deduplication and idempotent handlers make repeated delivery an expected condition, not an incident.

03

Campaign resolution

Intent separated from transport

Runtime events are resolved against communication intent before channel-specific work begins.

04

Delivery and evidence

Observable end to end

Delivery stages emit enough operational context to trace failures, recover work, and improve reliability.

Decisions and trade-offs

01At-least-once delivery

Model duplicate events explicitly and make handlers idempotent.

02Stage-level observability

Expose where work is accepted, resolved, queued, delivered, or failed.

03Shared infrastructure

Keep reliability behavior in one platform path instead of rebuilding it per campaign.

Internal implementation details intentionally summarized

Intent Safety Evidence
Case study / 02Neon

Usage and spending controls

The system

Customer-facing controls for configuring monthly spending limits and receiving proactive usage warnings.

My contribution

Helped shape the release boundary and built the backend model, public APIs, notification worker, frontend integration, and launch measurement.

Engineering considerations

ReactTypeScriptGoBilling systems
Case study / 03Neon

Project-scoped access control

The system

A permissions model for teams that need different levels of access across projects and environments.

My contribution

Worked from customer and product requirements through the role model, administrative interfaces, migration tooling, and staged rollout.

Engineering considerations

ReactTypeScriptGoPostgreSQL
Case study / 04Neon

External resource provisioning

The system

A partner-facing flow for creating, upgrading, and recovering managed database resources through an external platform.

My contribution

Owned the paid-path design and core implementation across identity, billing, APIs, resource ownership, and recovery behavior.

Engineering considerations

TypeScriptNode.jsREST APIsPostgreSQL

Contact / 05

Let's make a difficult system feel simple.

I'm always glad to talk about growth engineering, product infrastructure, developer experience, and the hard problems between them.

russ.dias@icloud.com