Pinpoint #837 is about things that are delivered. For a software engineer, the useful part is not merely the shared verb. The five clues show why an event called delivered needs a domain-aware contract instead of one overloaded Boolean.
The Saturday, August 15, 2026 clues are:
- A speech
- The daily newspaper
- The mail
- A knockout blow
- Restaurant food brought to you
The pinpoint answer is things that are delivered. A speech is performed, newspapers and mail are transported, a blow is applied, and restaurant food is handed to a customer. The same English verb covers different state transitions.
This article turns that observation into a small Python event model with explicit validation rules.
Why delivered = True is too weak
A Boolean answers only one question. It does not say what was delivered, which meaning of delivery applies, who or what received it, or which observation supports the transition.
order.delivered = True
That line may be convenient, but the model cannot distinguish these cases:
- a parcel was scanned at a doorstep;
- a speech was presented to an audience;
- a message was accepted by an upstream queue;
- a restaurant marked an order ready for pickup;
- a strike was recorded in a sporting event.
Those are not interchangeable facts. A robust event should preserve the domain meaning while still exposing a common vocabulary.
Model the verb sense explicitly
Start with an enum for the major senses represented by the clues.
from __future__ import annotations
from dataclasses import dataclass
from datetime import datetime, timezone
from enum import Enum
from typing import Mapping
class DeliveryMode(str, Enum):
PERFORMANCE = "performance"
TRANSPORT = "transport"
APPLIED_ACTION = "applied_action"
SERVICE_HANDOFF = "service_handoff"
The daily newspaper and mail fit TRANSPORT. A speech fits PERFORMANCE. The knockout blow is the crucial boundary case: it fits APPLIED_ACTION, not transport. Restaurant food may be modeled as SERVICE_HANDOFF when the important fact is receipt by the customer.
This is the puzzle's aha moment in software terms: the hardest clue breaks the assumption that every delivery has a shipping address.
Define evidence as data, not prose
A delivery event should carry an evidence type and a stable reference. The reference might identify a scan, recording, acknowledgment, or adjudicated match event. It should not contain a secret or an entire unbounded payload.
class EvidenceType(str, Enum):
AUDIENCE_RECORD = "audience_record"
CARRIER_SCAN = "carrier_scan"
RECIPIENT_ACK = "recipient_ack"
OFFICIAL_RESULT = "official_result"
HANDOFF_RECORD = "handoff_record"
@dataclass(frozen=True)
class DeliveryEvidence:
kind: EvidenceType
reference: str
def validate(self) -> None:
if not self.reference.strip():
raise ValueError("evidence reference must not be blank")
if len(self.reference) > 200:
raise ValueError("evidence reference is too long")
The model does not pretend that every evidence reference proves the same thing. The type tells downstream code how to interpret it.
Give the event a recipient and timestamp
A common event envelope can now represent all five clue families without forcing parcel-specific fields onto a speech or blow.
@dataclass(frozen=True)
class DeliveryEvent:
event_id: str
subject_id: str
mode: DeliveryMode
recipient: str
occurred_at: datetime
evidence: DeliveryEvidence
attributes: Mapping[str, str]
def validate(self) -> None:
if not self.event_id.strip():
raise ValueError("event_id must not be blank")
if not self.subject_id.strip():
raise ValueError("subject_id must not be blank")
if not self.recipient.strip():
raise ValueError("recipient must not be blank")
if self.occurred_at.tzinfo is None:
raise ValueError("occurred_at must be timezone-aware")
self.evidence.validate()
_validate_mode_and_evidence(self.mode, self.evidence.kind)
The recipient is intentionally general. It can be an audience, household, customer, or opponent. The model does not insist that it be a person or postal address.
Validate compatible combinations
The enum values prevent spelling drift, but they do not stop a carrier scan from being attached to a speech. Add a compatibility table.
_ALLOWED_EVIDENCE: dict[DeliveryMode, frozenset[EvidenceType]] = {
DeliveryMode.PERFORMANCE: frozenset({
EvidenceType.AUDIENCE_RECORD,
}),
DeliveryMode.TRANSPORT: frozenset({
EvidenceType.CARRIER_SCAN,
EvidenceType.RECIPIENT_ACK,
}),
DeliveryMode.APPLIED_ACTION: frozenset({
EvidenceType.OFFICIAL_RESULT,
}),
DeliveryMode.SERVICE_HANDOFF: frozenset({
EvidenceType.HANDOFF_RECORD,
EvidenceType.RECIPIENT_ACK,
}),
}
def _validate_mode_and_evidence(
mode: DeliveryMode,
evidence_type: EvidenceType,
) -> None:
if evidence_type not in _ALLOWED_EVIDENCE[mode]:
raise ValueError(
f"{evidence_type.value!r} is not valid for {mode.value!r}"
)
This table is intentionally closed. If a new domain needs another evidence type, a reviewer must decide which modes accept it. Silent fallback would make the taxonomy less trustworthy.
Construct one event from the puzzle's hardest clue
The knockout blow is a useful test because it contains no shipping route.
knockout_event = DeliveryEvent(
event_id="match-42:event-18",
subject_id="strike-18",
mode=DeliveryMode.APPLIED_ACTION,
recipient="competitor-b",
occurred_at=datetime(2026, 8, 15, 14, 30, tzinfo=timezone.utc),
evidence=DeliveryEvidence(
kind=EvidenceType.OFFICIAL_RESULT,
reference="match-42:official-result",
),
attributes={
"competition": "example-bout",
"result": "knockout",
},
)
knockout_event.validate()
The identifiers are illustrative, not claims about a real match. What matters is the shape: the endpoint is an opponent, and the evidence is an official result rather than a carrier scan.
Test the invariants
The tests should focus on the contract rather than enum implementation details.
from datetime import datetime, timezone
import pytest
def make_event(
*,
mode: DeliveryMode = DeliveryMode.TRANSPORT,
evidence_type: EvidenceType = EvidenceType.CARRIER_SCAN,
) -> DeliveryEvent:
return DeliveryEvent(
event_id="evt-1",
subject_id="subject-1",
mode=mode,
recipient="recipient-1",
occurred_at=datetime(2026, 8, 15, tzinfo=timezone.utc),
evidence=DeliveryEvidence(
kind=evidence_type,
reference="evidence-1",
),
attributes={},
)
def test_transport_accepts_carrier_scan() -> None:
make_event().validate()
def test_performance_rejects_carrier_scan() -> None:
event = make_event(
mode=DeliveryMode.PERFORMANCE,
evidence_type=EvidenceType.CARRIER_SCAN,
)
with pytest.raises(ValueError, match="not valid"):
event.validate()
def test_timestamp_must_be_timezone_aware() -> None:
event = DeliveryEvent(
event_id="evt-2",
subject_id="speech-9",
mode=DeliveryMode.PERFORMANCE,
recipient="audience-3",
occurred_at=datetime(2026, 8, 15),
evidence=DeliveryEvidence(
kind=EvidenceType.AUDIENCE_RECORD,
reference="program-9",
),
attributes={},
)
with pytest.raises(ValueError, match="timezone-aware"):
event.validate()
def test_evidence_reference_must_not_be_blank() -> None:
event = make_event()
blank_evidence = DeliveryEvidence(
kind=event.evidence.kind,
reference=" ",
)
invalid = DeliveryEvent(
event_id=event.event_id,
subject_id=event.subject_id,
mode=event.mode,
recipient=event.recipient,
occurred_at=event.occurred_at,
evidence=blank_evidence,
attributes=event.attributes,
)
with pytest.raises(ValueError, match="must not be blank"):
invalid.validate()
These tests cover one valid path and three failure boundaries. Additional domain tests can verify allowed evidence for restaurant handoffs, mail receipt, and recorded presentations.
Separate dispatched from delivered
The event taxonomy should not collapse intermediate states. A transport system usually needs at least:
prepared -> dispatched -> delivered -> verified
A restaurant may use:
accepted -> preparing -> ready -> handed_off
A speech might use:
drafted -> scheduled -> presented -> archived
Mapping all of those states to a single delivered flag at write time destroys useful information. If consumers need a shared dashboard, derive a common status from the domain event stream. Keep the original events as the source of truth.
Avoid three schema traps
1. Parcel fields in the base class
Do not require tracking_number, street_address, or weight in the universal event. Those fields exclude valid clues such as a speech and knockout blow. Put transport details in mode-specific attributes or a separate payload schema.
2. Evidence-free success events
An event named delivery_completed is still only an assertion. Require a reference to the observation that justified it, then define retention and access rules for that evidence.
3. Unbounded attribute dictionaries
The example includes attributes for extension, but production code should validate keys and sizes. Otherwise, consumers cannot rely on the contract, and sensitive data may leak into logs. A typed per-mode payload is preferable when the domain stabilizes.
Version the taxonomy when meaning changes
Event names and enum values become dependencies. If SERVICE_HANDOFF later includes locker pickup, define whether the existing meaning already covers it. If not, introduce a new schema version or event type rather than silently changing old events.
A practical envelope includes:
- schema name and version;
- globally unique event ID;
- subject ID;
- event timestamp and ingestion timestamp;
- mode;
- recipient identifier appropriate to the domain;
- typed evidence reference;
- validated mode-specific payload.
Consumers can then reject unsupported versions instead of misreading them.
What Pinpoint #837 contributes
The answer page for the puzzle is available from the independent Pinpoint Answer Today entry for #837. That is the only promotional link in this article.
The reusable design lesson comes from checking all five members, not just the easy transport examples. If the taxonomy handles newspapers, mail, and food but cannot represent a speech or a knockout blow, it has modeled shipping—not the broader idea of delivery.
Final answer and engineering takeaway
For Saturday, August 15, 2026, Pinpoint puzzle #837, the pinpoint answer is things that are delivered.
In Python, model that relationship with an explicit delivery mode, a general endpoint, timezone-aware occurrence data, and evidence compatible with the chosen mode. Keep intermediate domain states, validate the cross-field rules, and use the hardest valid example as the abstraction test.
Disclosure and source
By Li Zhan. Li Zhan contributes to Pinpoint Answer Today and prepared this independent software-design analysis of puzzle #837. Pinpoint Answer Today is an independent fan resource and is not affiliated with LinkedIn or Microsoft. AI assistance helped organize the draft; Li Zhan reviewed the clue list, date, answer, Python examples, validation logic, and final wording before publication.
Primary puzzle source: LinkedIn's public Pinpoint game, puzzle #837, observed August 15, 2026.