Software Architecture · Systems Research

Buddy Guzmán

Principal Software Engineer

I investigate how software architecture behaves under real operational constraints. What excites me most is turning architectural questions into systems I can build, test, compare and refine — then sharing what the evidence teaches me.

Technical ecosystems Java·Python
Buddy Guzmán
01 / INVESTIGATIONS

Current lines of inquiry

Architecture, distributed behavior, operational transformation and reproducibility.

Architecture · Determinism

Strong module boundaries without paying the distributed-systems premium too early.

The reference implementation uses a single deployable modular monolith with hexagonal boundaries. The technical question is not monolith versus hexagonal architecture; those describe different concerns. The interesting boundary is where deterministic decision authority ends and replaceable infrastructure begins.

JJava 25 SMSpring Modulith AUArchUnit HHexagonal boundaries
deterministic verifier
→
application use case
→
ports
→
adapters / persistence
Authority boundaryAdvisory components can produce observations, but cannot become the source of truth for the final decision.
Module enforcementDependencies remain explicit and verifiable in-process; separation does not require a network hop.
Extraction thresholdA module earns independent deployment only when scaling, ownership, release cadence or fault isolation justify it.
Technical note

Determinism here is structural, not merely conventional: canonical ordering, isolated verifier dependencies, injected time, stable hashing, immutable snapshots and replay verification remove nondeterministic inputs from the authoritative path.

  • The verifier remains isolated from agents, JPA, network and SQL APIs.
  • JPA is constrained to adapters.
  • Ports exist at seams where replacement is real, not as ceremony between every internal class.
Operating model · Public systems

Redesign the operating model before digitizing the existing friction.

This thesis line studies public-education operations around UGEL 04: institutional responsibility, process handoffs, controls, decision rights and the difference between automation and actual operating-model transformation.

OMOperating model DXDigital transformation BPProcess architecture GGovernance
MINEDU
→
DRELM
→
UGEL 04
→
operational redesign
Process lensIdentify handoffs, control points, delays, duplicated activity and decision ownership before selecting technology.
Transformation lensA digital interface that reproduces the same operating model may digitize work without transforming it.
Scope disciplineAdjacent regulatory relationships remain explicit assumptions until the thesis framework formally validates them.
Technical note

The research model separates institutional governance from operational execution. SUNEDU is therefore treated as an adjacent regulatory reference under scope validation rather than being forced into the MINEDU → DRELM → UGEL operational chain.

Experimental systems · Uncertainty

Uncertainty should be modeled as state, not hidden behind a confident output.

This line studies evolving computational hypotheses: how signals become observations, how confidence changes, how revisions are preserved, and how an experiment can expose its own uncertainty without pretending to be authoritative.

PHPPHP ETLData ingestion ΔConfidence deltas AUDAudit trail
signals
→
observations
→
hypothesis state
→
revision history
Stateful uncertaintyConfidence changes become first-class state transitions rather than decorative percentages.
Evidence provenanceEvery revision should remain traceable to the evidence that caused it.
Research boundaryAn exploratory model remains visibly experimental; presentation must not imply operational authority.
Event-driven systems · Failure semantics

Exactly-once transport does not guarantee exactly-once business effect.

The hard problem starts when a reliable event crosses a transaction boundary and touches an external side effect. Idempotency belongs where the business invariant can actually be protected.

KKafka IDIdempotency TXTransactions OBOutbox pattern
event delivery
→
handler
→
business invariant
→
external side effect
IdentityThe idempotency key should represent the business operation, not merely the transport message.
BoundaryA transaction protects only what it actually encloses; external calls create a different failure surface.
RecoveryRetries are safe only when duplicate effects are structurally prevented or reconciled.
TypeScript backend · Boundary design

External data changes faster than the domain model should.

This queued case study examines a Node.js/TypeScript backend where external data, validation, pagination, pricing checks and reporting cross several service boundaries. The public write-up will remain architecture-only until source material is fully sanitized.

TSTypeScript NNode.js APIExternal APIs VALValidation
provider data
→
normalization
→
domain service
→
reporting / side effects
Python · Cloud orchestration

Reproducibility is an architectural property, not a deployment afterthought.

A clean-room Python example is planned around event orchestration, retries, idempotency, observability and infrastructure as code using synthetic data and independently reproducible behavior.

PyPython AWSAWS IaCInfrastructure as Code SFWorkflow orchestration
event
→
orchestrator
→
idempotent step
→
audit / observability
RepeatabilityEquivalent inputs should produce explainable, inspectable outcomes across runs.
Operational safetyRetries, timeouts and partial failure must be deliberate parts of the state machine.
ProvisioningInfrastructure definitions become part of the reproducible artifact rather than hidden setup knowledge.
Agentic systems · Semantic governance

When knowledge becomes executable state, semantics need versioning too.

Agentic systems increasingly act against enterprise knowledge, policy and tool permissions that evolve independently. This research thread studies how to preserve decision authority when the semantic context itself changes over time.

KGKnowledge graph / ontology PaCPolicy as Code TVTemporal validity PRProvenance RPReplayability
ontology rev N
→
agent proposal
→
deterministic policy gate
→
action + audit
Semantic pinningA decision should retain the ontology and policy revisions that defined its meaning at execution time.
Temporal provenanceFacts need source and validity windows so later knowledge does not silently rewrite historical context.
Stale-state fencingOlder semantic revisions should not remain operationally authoritative after ownership or policy has moved forward.
Technical note

Replayable agent decisions require more than storing the prompt and output. A meaningful replay may need the input, model revision, ontology revision, policy revision and tool-authorization state that were active when the action was evaluated.

  • Semantic drift becomes an architectural concern once knowledge can authorize behavior.
  • Policy evaluation should be pinned to an explicit revision rather than “whatever is current”.
  • Provenance and temporal validity make historical decisions explainable without reinterpreting them through today’s semantics.
Currently exploring semantic authority agent governance deterministic replay operating-model transformation
02 / FIELD NOTE

Production reasoning

Debugging

When tests pass and reality does not

Before touching the implementation, reconstruct the smallest failing path and challenge the invariants behind the expected behavior. Code expresses intent; production evidence reveals where that intent stopped matching reality.