Vicente Damasceno
EN
Menu
Engineering notebookSoftware Engineer

Software, product, and the decisions in between.

Vicente Damasceno Ideas in practice

Featured essayJuly 30, 2026

When scheduling becomes mathematics

Building a CP-SAT engine: human rules, mathematical constraints, and a decision that stays with the person using it.

Read here →

More to read

Technical note · Applied AI

What an HTTP 200 leaves unsaid

A successful response can still carry a failure. That is the problem behind Jev Resilience.

Note · Learning

Technical depth, product perspective

How cloud architecture and Product Ownership connect in my learning.

Projects

From writing to working software.

Real interfaces, code, and the decisions behind the products.

01 / Web product · Clinical education

Diagnostique

A daily clinical reasoning game in Portuguese. Progressive clues, up to six attempts, and a library of past cases.

Actual Diagnostique screen showing the initial clue and locked later clues.
01Detail from the actual productCaptured October 21, 2026Enlarge image

Decision 01

Revealing a clue is also an API decision.

The React and TypeScript interface tracks the attempts. The Fastify backend determines what information the session can receive at each step.

The initial response includes the revealed clues and the total clue count. The correct answer and explanation are left out of that state.

Editorial representation of the implemented flow
What the test checks

The serialization test compares returned clues with the revealed subset and checks that the answer, explanation, and a future clue are absent. This is contract evidence in the code, not a usage metric.

↑ Back to the evidence
Diagnostique’s actual case library.
02Case libraryCaptured October 21, 2026Enlarge image

Decision 02

History keeps its reference.

Content definitions have revisions in SQLite. A publication references one of those revisions, preserving the context in which a session began.

Content tests check that an edit creates a new revision without replacing the historical definition, and that earlier publications keep their reference.

The relationship that stays intact

The tests cover both the historical definition and the link between publication and revision. The library screenshot gives history a visible context; the implementation and tests provide the evidence of consistency.

Trade-off. Preserving revisions maintains consistency, but requires separate definitions, revisions, and publications. Updating content is no longer a simple replacement of the previous record.

Open Diagnostique · Opens in a new tabPrivate source code

Fictional cases for educational use.

02 / Open source · Reliability

Jev Resilience

A Spring Boot starter for detecting semantic failures in responses from WebFlux services.

Test fixture · not production traffic
{
  "status": "ok",
  "note": "system under maintenance"
}
01Payload used in the evaluation client’s offline test.View source · Opens in a new tab

Decision 01

Evaluation joins the reactive pipeline.

The aspect composes evaluation into the returned Mono or Flux. The item either passes through or becomes a SemanticFailureException. The call is non-blocking; it does not have zero latency.

Excerpt from the public implementation
return jevEvaluationService.evaluateSilentFailure(payload)
    .flatMap(score -> {
        if (score > threshold) {
            return Mono.<T>error(
                new SemanticFailureException(score, payload));
        }
        return Mono.just(item);
    });
The screen method · real code, with formatting adjusted.View source · Opens in a new tab
Existing offline test
server.enqueue(new MockResponse()
    .setResponseCode(500).setBody("boom"));

Double score = service
    .evaluateSilentFailure("irrelevant payload").block();

assertThat(score).isEqualTo(0.0);
02failsOpenWhenServerErrors · a test using a mocked evaluator response.View source · Opens in a new tab

Decision 02

Failing open is an explicit choice.

The test sets up a 500 response from the evaluator and expects a score of 0.0. The service also applies a timeout and onErrorReturn(0.0). This 500 belongs to the mocked dependency, not to the original service’s transport.

The fallback implementation

The fallback prevents an evaluator outage from becoming an application failure. Above the threshold, the aspect emits the exception; in the fallback, the score is 0.0.

.timeout(properties.getTimeout())
.map(response -> extractScore(response, properties.getQuestionKey()))
.doOnError(error -> log.warn(
    "Jev evaluation failed, failing open (treating payload as valid): {}",
    error.toString()))
.onErrorReturn(0.0);
View source · Opens in a new tab

Trade-off. Fail-open preserves continuity, but can let a semantic failure through when the evaluator is unavailable. External evaluation also adds latency, cost, and an operational dependency.

Code and tests on GitHub · Opens in a new tab

These excerpts contain real code and fixtures from the repository. They are not production traffic, benchmarks, or a test run performed by this page.

Vicente Damasceno

The person behind the work.

I’m Vicente Damasceno, a software engineer. I build backend systems and web products, connecting Java, Spring Boot, React, and cloud architecture to product problems. I explore applied AI as part of software systems, with attention to its limits and costs.

Milestones

Cloud and product belong in the same conversation.

AWS Certified Solutions Architect – Associate
Cloud architecture as part of my technical foundation. View source · Opens in a new tab
Professional Scrum Product Owner II
Technical depth alongside product and business understanding. View source · Opens in a new tab

Diagnostique screenshots

Captured October 21, 2026Open original image ↗