Software engineerturning ideas into products.
From understanding the problem to design, development and launch.
(02)
Selected work
Production systems and focused prototypes — the problem, the decisions, the data flow and what each project proved.
All projects →(03)
Writing
Filter by section
Selected writing
- Testing System Boundaries with Real PostgreSQLMigration-built test databases, restricted login roles and assertions on stored state make permissions and transaction behavior testable beyond mocks.
- Document Signing: Preserve the Content and the Event HistoryVersioned templates, document fingerprints, expiring links and serialized state changes make a signing workflow traceable.
- FLP Impossibility: Why a Correct System May Never DecideBuild the FLP proof from indistinguishable executions, bivalent configurations, and a fair schedule that keeps a deterministic protocol undecided.
- Production Logging: From Printed Strings to Traceable EventsGood logs do not record everything. They reconstruct requests, jobs and business events while controlling sensitive data, storage cost and alert noise.
- Shared Accounts, Separate Data AccessHow application permissions, database grants and transaction-scoped row-level security work together across customer and staff applications.
- Consensus and Paxos: How a Decision Survives a Failed LeaderWork through synchronous consensus, Paxos ballots, and a leader crash to see why accepted, chosen, and learned are different states.
- How Do You Rotate Keys After Encrypting Files? Envelope Encryption ExplainedEncrypt data with a DEK, then protect that DEK with a KMS-managed KEK. This two-layer model makes rotation, migration and retirement practical.
- CS 411 Visual Guide to Database InternalsFollow pages through scans, B+ trees, hash splits, external sorting, join buffers, query plans, and transaction conflict graphs.
- Multicast in Practice: Ordering, Reliability, and View ChangesWork through FIFO buffers, causal delivery vectors, a total-order sequencer, and the membership boundaries that virtual synchrony protects.
- When Should You Use a Message Queue? First Prove You Need AsynchronyQueues decouple systems, fan out events and absorb bursts, but introduce duplicate delivery, eventual consistency and tracing costs. Small systems may not need one.
- Safety and Liveness: What Correctness Actually PromisesSeparate invariants from progress, understand finite counterexamples and fairness, and use global snapshots to reason about stable properties.
- CS 513 Visual Guide to Data CleaningStep through name clustering, alternative database repairs, provenance links, workflow runs, and concept alignment.
- Global Snapshots: Consistent Cuts and the Chandy-Lamport AlgorithmFollow a transfer through process and channel state, then work through a complete three-process marker snapshot and its correctness argument.
- If ECS Can Run Cron, Why Do We Need Function Compute or Lambda?Function Compute and Lambda are not automatically cheaper than an existing server. The real trade-off is idle capacity, isolation, event integration, burst scaling and operational ownership.
- CS 425 Midterm Visual Guide: Distributed Systems in MotionAn interactive review of partial failure, P2P routing, gossip, SWIM, logical clocks, multicast order, MapReduce recovery, quorums, and Cassandra.
- Reliable AI Workflows Need Boundaries, Abstention, and EvidenceA reusable architecture extracted from BIM and quantity workflows: Human > Agent > Rule, legitimate abstention, deterministic computation, stop conditions, evidence and rule learning.
- Before Designing the System, Peel the Requirement Back to the Real ProblemStakeholders often describe the end state while engineers hear a specification for today. This is how I learned to separate vision, present needs, extensibility and cost.
- Trusting AI Agents Starts with Designing the EnvironmentLauren Tan's agent workflow, plus the harder questions raised around PR metrics, autonomous merging, portability and human responsibility.
- AI Agents Do Not Need More Tools: Armin Ronacher's Conservative ApproachWhat Pi's minimal harness, local-first workflow and insistence on real environments reveal about building software with agents.
- SAA-C03 Final Review: Cost Decisions and the Traps Worth MemorizingFinish the series with cost levers, frequently confused pairs and a compact method for reviewing practice questions.
- AWS Data and Analytics: Choose the Engine From the QuestionMap ad hoc SQL, warehouses, ETL, streams, search, dashboards and clusters to the service that owns each job.
- From CAP to Cassandra and HBase: Consistency Is an API ContractConnect partition behavior, consistency models, quorums, LSM-style writes, Cassandra, and HBase without reducing design to CAP slogans.
- AWS Resilience and Migration: Let RTO and RPO Drive the ArchitectureSeparate high availability from disaster recovery, then map business recovery targets to replication and migration tools.
- MapReduce: Move Computation to Data and Recompute on FailureUnderstand map, shuffle, reduce, partitioning, stragglers, speculative execution, and lineage-based fault tolerance.
- AWS Observability and Governance: Metrics, Events, Audit, and ConfigurationStop mixing CloudWatch, EventBridge, CloudTrail and Config by asking what each service records and acts on.
- Consensus and Paxos: Majorities Preserve One DecisionSeparate consensus safety from progress, then follow proposals, acceptors, ballots, and quorum intersection in Paxos.
- AWS Messaging and Serverless: Design Delivery Semantics FirstSeparate queues, pub/sub, streams and orchestration before connecting Lambda, API Gateway and event-driven workloads.
- A Dockerized Local Database for AI-Assisted Development Without Production AccessHow I used local PostgreSQL, a masked seed, and a reproducible setup for AI-assisted development—and what this boundary does and does not protect.
- Global Snapshots: Capture Distributed State Without Stopping the WorldUnderstand consistent cuts, in-transit messages, and the Chandy-Lamport marker algorithm.
- AWS Databases and Caches: Start From the Data ContractChoose RDS, Aurora, DynamoDB, ElastiCache or a purpose-built database from consistency, query and scale requirements.
- Time Without a Global Clock: Causality and Multicast OrderMove from clock synchronization to Lamport timestamps, vector clocks, FIFO, causal, and total-order multicast.
- AWS Storage: Choose by Access Pattern, Sharing, and RecoveryCompare object, block and file storage before choosing classes, replication, lifecycle and hybrid transfer tools.
- Gossip, Membership, and Failure Detection Under UncertaintyConnect epidemic dissemination, membership views, heartbeats, suspicion, false positives, and scalable failure detection.
- AWS Compute and Elasticity: Match Runtime, Scaling Unit, and Failure ModelChoose among EC2, Auto Scaling, load balancers, containers and Lambda by control, workload shape and state.
- From Napster to Chord: Why Peer-to-Peer Systems Became StructuredCompare centralized indexes, flooding, supernodes, BitTorrent swarms, and DHT routing through state, messages, and failure behavior.
- From pgvector to an Answer Gate: My Knowledge-base RAG MVPA locally tested, not-yet-deployed health-education Q&A MVP: curated articles, pgvector retrieval, answer gates, follow-up rewriting, and citation checks.
- AWS Networking and Edge: Trace the Packet Before Choosing the ServiceConnect subnets, routing, security, private access, hybrid links, DNS and global delivery through packet paths.
- Clouds Are Distributed Systems With an Operating ModelStart from partial failure, concurrency, elasticity, virtualization, and the economic reason cloud systems exist.
- AWS Identity and Security: Follow the Request, Then Find the DenyConnect IAM evaluation, Organizations, KMS, secrets, network protection and detection services into one security model.
- SAA-C03 Study Map: Learn Decisions, Not a List of ServicesTurn the four exam domains into a repeatable way to read requirements, eliminate distractors and select an architecture.
- Cleaning 17,545 Historical Menus Without Erasing the EvidenceA project retrospective on profiling, canonical cities and meals, conservative inference, constraints, provenance, and honest validation.
- Cost-Aware Learned Caching: From LBSC to a Testable System ProposalWhy miss count is the wrong objective for heterogeneous storage, how LBSC learns eviction, and how to scope a credible follow-up experiment.
- Taxonomy Alignment: Same Labels Do Not Guarantee the Same MeaningAlign hierarchical vocabularies with explicit semantic relations, logical constraints, possible worlds, and human review.
- NoDB Revisited: Querying Raw Data Without Paying the Load Cost FirstA practical critique of NoDB's data-to-query argument, selective parsing, positional maps, caching, and break-even point.
- Research Nexus: What a Real Dataset Changed About the Database DesignA design review of an 11-table research-discovery database built from DBLP-style citation data and Scholar enrichment.
- Data Provenance: Explain Where a Result Came FromSeparate prospective and retrospective provenance, model lineage at useful granularity, and annotate scripts with YesWorkflow-style dependencies.
- Information Integration: From Messy Sources to Trustworthy DataA practical guide to schema matching, entity resolution, provenance, merge policy, ETL, and federated queries.
- Data-Cleaning Workflows: Automation Is Not ReproducibilityDesign cleaning pipelines around explicit inputs, outputs, parameters, dependencies, validation gates, and rerunnable evidence.
- Parallel and Distributed Databases: Optimize Data Movement FirstConnect partitioning, replication, parallel joins, skew, distributed commit, and consensus without collapsing them into one topic.
- Business Time: Consistent Boundaries for Orders and ReconciliationSeparate an instant from its business date, and use explicit period boundaries across reports, identifiers and scheduled work.
- Database Recovery: WAL, Checkpoints, Undo, and RedoUnderstand what survives a crash, why write-ahead logging works, and how buffer policies determine undo and redo work.
- Database Repair: When Several Clean Versions Are PossibleReason about minimal repairs, repair policies, stable conclusions, and consistent query answers without hiding ambiguity.
- Relational, Document, Graph, or Raw Data: Choose From the WorkloadCompare data models by invariants, access paths, update ownership, relationship depth, latency, and operational cost.
- Query Optimization: Cardinality Before CostRule-based rewrites, selectivity estimates, join order, physical-plan cost, and a disciplined way to read estimation errors.
- Datalog and Recursive Queries: A Small Language for Data RelationshipsUnderstand facts, rules, joins, recursion, fixed points, and how the same reasoning appears in recursive SQL and data-quality checks.
- From Relational Algebra to Physical Operators: Where Query Cost Comes FromSeparate logical meaning from scan, sort, hash, and join algorithms, then estimate their page-I/O cost.
- Transactions, Serializability, and Isolation: Reasoning About Concurrent WritesFrom ACID and schedules to conflict graphs, anomalies, isolation levels, locks, and evidence from two database sessions.
- Integrity Constraints as Executable Data-Quality RulesTranslate keys, references, domains, and cross-column business rules into violation queries and enforceable constraints.
- B+ Trees and Hash Indexes: Choosing Through Page I/OTree structure, fanout math, update cost, runnable PostgreSQL, EXPLAIN interpretation, and a practical index decision table.
- Graph Data Modeling and Cypher: Make Relationships First-ClassModel nodes, relationships, direction, and traversal cost in Neo4j without turning every dataset into a graph.
- OpenRefine: Explore First, Transform Second, Export the RecipeUse facets, clustering, GREL, reconciliation, and operation history without turning interactive cleaning into an unrepeatable black box.
- MongoDB Data Modeling: Flexible Schema Still Requires DesignChoose embedding or references from access patterns, growth bounds, update ownership, and measurable query plans.
- Functional Dependencies and Normalization: From Closure to 3NF and BCNFA worked reasoning chain for attribute closure, candidate keys, minimal covers, lossless decomposition, 3NF, and BCNF.
- Regular Expressions for Data Cleaning: Match Structure, Not MeaningBuild testable regexes for validation, extraction, and transformation while keeping parsing and semantic checks separate.
- From Conceptual Model to Tables: Preserving Meaning During DesignA repeatable path from requirements to entities, relationships, keys, cardinalities, and relational tables.
- Constraints and Triggers: Put Invariants Where Every Writer Must ObeyA practical hierarchy for NOT NULL, CHECK, UNIQUE, foreign keys, and triggers—with failure behavior you can test.
- Profile Before You Clean: Turn Suspicion Into Measurable DefectsBuild a data profile that separates syntax, schema, semantic, duplicate, missingness, and distribution problems before changing values.
- Aggregation, Views, and Updates: Choosing the Right BoundaryGROUP BY semantics, ordinary and materialized views, atomic updates, and when a stored routine is worth the coupling.
- Joins, NULL, and Set Operations: Keeping Multi-Table Queries CorrectJoin cardinality, outer-join filters, NULL-safe anti-joins, and when UNION ALL is the honest operation.
- Data Quality Starts With the Question, Not the DatasetUse fitness for use, quality dimensions, and cost to decide what must be cleaned and what is already good enough.
- From Relations to SQL: The Model Behind a QueryRelations, schemas, keys, bags, NULL, and SQL's logical processing order—one mental model for reasoning about query results.
- Checkout Concurrency: Inventory, Balance Holds and State TransitionsOrdered locks, fresh availability reads and conditional transitions make competing checkout and cancellation requests explicit.
- Modelling Promotions: Rules, Ownership and UsageA shared promotion lifecycle with explicit ownership, concurrency-safe usage checks and preserved order amounts.
- Beyond Batch Spark: Streaming, Graphs, and Machine-Learning PipelinesUse one execution foundation for incremental streams, property graphs and repeatable feature-to-model workflows.
- Stored Decisions and Computed EligibilityDistinguishing durable business decisions from eligibility that changes with transactions, refunds and reporting periods.
- Spark DataFrames and SQL: Give the Optimizer More InformationUnderstand why schema, logical plans, Catalyst and columnar execution often beat opaque RDD code.
- Market, Channel and Account: Three Separate ResponsibilitiesHow explicit market policy, sales channels and billing ownership let retail and B2B share a platform without mixing prices, units or permissions.
- Spark RDDs: Lazy Execution, Lineage, Partitions, and ShufflesRead Spark performance from the execution model instead of treating transformations as ordinary collection methods.
- Clustering and Classification: Similar Tools, Different QuestionsConnect k-means, decision trees and SVMs through objectives, assumptions, boundaries and evaluation.
- Association Rules: From Apriori Pruning to FP-GrowthUnderstand support, confidence and lift, then see why Apriori and FP-Growth spend work differently.
- MinHash and LSH: Find Near-Duplicates Without Comparing Every PairTurn documents into shingles, compress Jaccard similarity into signatures, then use LSH to generate a small candidate set.
- Turning CODA Bank Files into an Auditable Reconciliation PipelineHow a Belgian coded bank statement moves from Isabel or secure file transfer through fixed-width parsing, matching, review and idempotent ledger posting.
- A Payment Did Not Fail Just Because HTTP Timed OutA practical map of PSPs, banks, authorization, capture, void, refund, hosted card fields, signatures and webhook-driven payment state.
(04) — Work with me
Got a problem to solve?
01Requirement shaping
Turn goals, user needs and constraints into clear scope, priorities and an executable technical plan.
02Architecture & delivery
Design domain models, data flows, APIs, cloud and integrations, then carry the plan through tested production code.
03Scale, reliability & cost
Find bottlenecks, failure paths and cost drivers, then plan sensible growth without premature complexity.
04Technical ownership
Own trade-offs, milestones and technical quality from discovery to launch, or strengthen an existing team where it needs help.