DEV Community: Erwin Wilson Ceniza2

Git Guide with Real-World Examples, Workflows, and Visuals

Erwin Wilson Ceniza2 — Sun, 12 Jul 2026 11:50:45 +0000

Hey fellow devs, ever feel like you're just button-mashing with Git instead of truly understanding what's going on under the hood?

This article totally flips that script. It covers Git not just as version control, but as a powerful, distributed graph database. It walks through everything from your first git init to confidently handling complex merges and large-team workflows, complete with visuals.

Here are some highlights:

Built by Linus Torvalds in 2005 for thousands of contributors.
Emphasizes Git's "four-area architecture": Working Directory, Staging Area (Index), Local Repository, and Remote.
Core design principles: every clone is a full backup, everything is local, and branches are cheap.
Cryptographic integrity ensures every object is hashed (originally SHA-1, migrating to SHA-256).
Uses interactive code-morph transformations and visuals, like Mermaid diagrams, to explain complex concepts.
Dives into advanced topics like rebasing, troubleshooting, and real-world team workflows.

Understanding these core concepts changes Git from a chore into a precision tool you wield with intention.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/git-guide-with-real-world-examples-workflows-and-visuals

From Chaos to Clarity: SOLID, CQRS and Clean Architecture Explained

Erwin Wilson Ceniza2 — Sat, 11 Jul 2026 05:15:46 +0000

Ever found yourself staring at a monstrous controller, thinking 'how did we even get here?' Yeah, been there. This article dives deep into exactly that architectural chaos, showing how SOLID principles, CQRS, and Clean Architecture can rescue your codebase from becoming an unmaintainable mess.

It walks through the core concepts, providing a roadmap for turning complex, tightly coupled systems into clear, maintainable solutions.

Highlights the perils of a controller bloated with "15 more dependencies" and "300 lines of spaghetti" business logic.
Breaks down each of the five SOLID principles (Single Responsibility, Open/Closed, Liskov, Interface Segregation, Dependency Inversion) with practical examples.
Explains CQRS by clearly distinguishing Commands (for state changes) from Queries (for data retrieval).
Details Clean Architecture's layered approach, separating core business rules from external concerns like databases or UIs.
Illustrates these concepts with a complete e-commerce implementation example.
Touches on effective testing strategies and common architectural pitfalls to avoid.

Ultimately, it's about building scalable, maintainable systems that don't make you want to rewrite everything from scratch every two years.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/from-chaos-to-clarity-solid-cqrs-and-clean-architecture-explained

Code Galaxy: Turning Your Codebase Into a Freaking Solar System

Erwin Wilson Ceniza2 — Thu, 09 Jul 2026 15:10:52 +0000

Ever opened your codebase and just... felt that familiar dread? All those files, folders, and then you try a dependency graph tool and it promptly crashes your browser tab with 8 gigs of RAM eaten? Yeah, been there.

Well, this article totally flips that on its head. It walks through building "Code Galaxy," a ridiculously cool way to visualize your codebase, turning it into a freaking solar system you'd actually want to explore.

Here's why it's different:

It re-imagines your App.tsx as a glowing blue star at the center of the system.
Major modules like AuthModule become Jupiter-sized planets, color-coded for their "community" (e.g., rusty red for Mars).
Individual functions like login() or hashPassword() are represented as tiny orbiting moons.
Dead code is visually rendered as distant, ominous black holes.
The goal is "visual storytelling" and fostering an "emotional connection to code," moving beyond static 2D diagrams.
It prioritizes "smooth 60fps exploration" to avoid the typical lag and crashes of traditional tools.
It's pitched as an "over-engineered, deeply entertaining way" to understand architecture, far more engaging than "dots and lines."

Traditional code graphs are often useless blobs; this makes architecture discovery genuinely fun and insightful.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/code-galaxy-turning-your-codebase-into-a-freaking-solar-system

How to Talk to Your Database Using AI: A Practical Implementation Guide

Erwin Wilson Ceniza2 — Mon, 06 Jul 2026 06:55:51 +0000

Let’s be honest—writing raw SQL queries to answer basic business questions for non-technical stakeholders gets old fast. I recently came across a great guide on building a reliable Text-to-SQL agent that actually works without nuking your production database.

It walks through building a production-ready AI database assistant that translates natural language into secure, optimized SQL.

Utilizing GPT-4o and Claude 3.5 Sonnet as the backbone for generating complex, multi-table joins.
Implementing LangChain and ChromaDB to dynamically pull the most relevant schema definitions based on the user's question.
Schema pruning techniques to keep context window usage under 4k tokens for faster response times and lower API costs.
Enforcing strict security protocols, including read-only connection strings and a 5-second execution timeout limit.
Implementing a regex-based validation layer to block destructive commands like DROP or DELETE before execution.
Boosting query accuracy from 65% to over 90% using dynamic few-shot prompt templates.

At the end of the day, LLMs are incredibly smart, but never trust an AI with write access to your database without a rock-solid sandbox in place.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/how-to-talk-to-your-database-using-ai

The Laws of Diminishing Returns in AI: When Bigger Is No Longer Better

Erwin Wilson Ceniza2 — Fri, 03 Jul 2026 22:05:55 +0000

Let’s face it—we've been obsessed with "bigger is better" in AI for years, but throwing more GPUs at the problem is starting to hit a major wall. I've been tracking how scaling laws are flattening, and it's clear the era of just doubling parameters for easy performance gains is over.

This article walks through the shift from brute-force compute scaling to efficient, domain-specific AI architectures.

The shift from the Scaling Era (2017–2024) to the Diminishing Era (2025+) where returns on pure compute are rapidly eroding.
Why scaling a model's compute budget by 3.6x annually now only yields fleeting, marginal performance advantages.
The trajectory shift from linear cost and super-linear gains (2017–2022) to hyper-exponential costs and sub-linear plateaus (2025+).
The rise of "meek" models that allow small teams with a $1M budget to rival tech giants playing with $1B+ budgets.
How fine-tuning specialized data on efficient architectures levels the playing field against raw 500B+ parameter models.

The real takeaway is that winning in AI is no longer about who has the biggest GPU cluster, but who builds the smartest, most efficient pipelines.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/the-laws-of-diminishing-returns-in-ai

GraphQL Query & Mutation Architecture, A Production Deep Dive

Erwin Wilson Ceniza2 — Thu, 02 Jul 2026 00:35:23 +0000

I’m sharing what I learned building a production GraphQL API: how to design query and mutation architecture that scales without losing consistency or clarity. This article walks through a code-first HotChocolate implementation using BatchDataLoader, CQRS, and the transactional outbox pattern, with real examples from an EMR system serving three portals via a single schema.

Key takeaways:
— How to structure GraphQL queries and mutations cleanly in a .NET code-first approach
— Using BatchDataLoader to prevent N+1 problems while keeping resolvers maintainable
— Applying CQRS to separate read and write concerns without complicating the API layer
— Pairing writes with a transactional outbox pattern for reliable, production-grade event delivery

Read the full article here: https://erwinwilsonceniza.qzz.io/blogs/graphql-query-mutation-architecture-a-production-deep-dive

GraphQL #DotNet #CSharp #HotChocolate #CQRS #OutboxPattern #DesignPatterns #EnterpriseArchitecture #DotNetConf #GraphQLAPI

Automating Dev.to Cross-Posts with n8n: From Manual to Hands-Free in 10 Minutes

Erwin Wilson Ceniza2 — Tue, 30 Jun 2026 23:20:25 +0000

I finally got tired of manually copy-pasting my blog posts over to Dev.to. It’s one of those chores that either gets forgotten or ends up with broken formatting and missing canonical links, so I decided to automate the whole thing.

The article walks through building a self-hosted automation pipeline using n8n that pulls content from a personal portfolio and syndicates it perfectly every time.

Configures a 5-minute polling interval via a Schedule Trigger to check for new content.
Uses a Function node to isolate exactly one blog post per run to prevent bulk-processing errors.
Integrates a custom AI summary step using Gemini to transform long-form content into punchy, Dev.to-friendly versions.
Navigates the Dev.to API rate limit of 30 articles per 30 seconds using a mandatory 30s Wait node.
Automatically handles SEO requirements by injecting the original canonical_url into the API payload.
Secures the workflow using Bearer auth to fetch unposted items from a private /unposted-devto endpoint.
Closes the loop by updating your internal database via a /devto-mark endpoint once the post is live.

Automating your distribution is great, but if you don't build in rate-limit safety and canonical links from day one, you’re just creating a technical debt nightmare for your SEO.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/automating-devto-cross-posts-with-n8n-from-manual-to-hands-free-in-10-minutes

Building a Binary MLM System: From Tree Algorithms to Transactional Ledgers

Erwin Wilson Ceniza2 — Tue, 30 Jun 2026 23:15:15 +0000

Ever had to build a system where every single user action triggers a recursive recalculation across a massive, branching tree? I recently went down the rabbit hole of Multi-Level Marketing (MLM) architecture, and it is a lot more complex than just drawing circles on a whiteboard.

The article walks through the heavy lifting required to build a binary commission engine from scratch, focusing on the intersection of tree data structures and high-integrity financial ledgers.

Implementation of the Binary Tree Algorithm to manage strict left and right "legs" for every distributor.
Real-time Point Volume (PV) propagation that rolls up sales data from child nodes to the root.
Using a Double-Entry Transactional Ledger to ensure commission payouts are immutable and audit-ready.
Logic for Balancing Thresholds (like the common 1:1 ratio) to trigger automated payouts once specific PV targets are met.
Optimizing database reads using the Nested Set Model to handle deep tree traversals without hitting recursion limits.
Utilizing Idempotency Keys in the commission engine to prevent double-counting during high-concurrency event processing.
Solving the "Flash-out" problem where excess volume is cleared based on daily or weekly earning caps.

The real challenge isn't just the tree traversal; it’s keeping the ledger perfectly balanced when thousands of nodes are triggering commission calculations at the same time.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/building-a-binary-mlm-system-from-tree-algorithms-to-transactional-ledgers

The Functional Workflow of a Cold Storage WMS: From Supplier to Storage

Erwin Wilson Ceniza2 — Tue, 30 Jun 2026 23:10:25 +0000

Ever had a batch of frozen seafood turn into a soggy mess because someone left the truck in the sun too long? It’s a nightmare. I’ve been looking into how a Warehouse Management System (WMS) actually handles these high-stakes cold chain logistics beyond just simple CRUD operations.

This article walks through the end-to-end functional workflow of a cold storage WMS designed for 3PL providers. It covers the logic required to keep products from spoiling before they even hit the racks.

Managing specific temperature zones including Chilled, Frozen, Deep Frozen, and Ultra-Low Temperature (ULT) storage.
Handling core temperature thresholds, such as flagging items that arrive at -8°C when the required storage temp is -18°C.
Appointment scheduling logic that reserves specific dock time slots to minimize exposure to ambient air.
Yard Management systems (YMS) that track truck arrival times and assign specific yard spots to prevent "warm" delays.
Pallet-level batch tracking that links material data to specific receiving scans during the unloading process.
System-driven putaway algorithms that automatically suggest locations based on the product’s specific temperature zone and batch requirements.
Integration between the physical weight scales and the WMS to ensure real-time inventory accuracy during receiving.

At the end of the day, a WMS isn't just about moving boxes; it's about making sure your inventory doesn't literally melt away while sitting in the yard.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/the-functional-workflow-of-a-cold-storage-wms-from-supplier-to-storage

Engineering a Cross-Platform Face Recognition Pipeline with Anti-Spoofing

Erwin Wilson Ceniza2 — Tue, 30 Jun 2026 22:55:14 +0000

I recently went down a rabbit hole after hearing how a major bank’s ATM face scanners were defeated by a literal piece of printer paper. It’s a classic example of what happens when we build for the "happy path" instead of the real world. If you’re building biometrics for something like employee clock-ins or secure access, you can’t just rely on a basic detection demo—you need a pipeline that actually knows the difference between a human and a photo.

This article walks through building a cross-platform, offline-first face recognition system that handles everything from the initial camera frame to the final identity match.

Runs lightweight AI models locally via ONNX, making it fast enough for mobile devices and tablets.
Filters out noise by requiring a minimum detection confidence score of 0.7.
Cleans up overlapping boxes using Non-Maximum Suppression (NMS) at a 0.4 IoU threshold.
Implements a dedicated anti-spoofing layer using a 112x112 face crop and a 2-class softmax model.
Requires a spoof score of 0.1 or lower to ensure the subject is a live person, not a printout or screen.
Generates 128-dimensional face signatures (embeddings) using FaceNet for high-precision matching.
Uses HNSW indexing to search through thousands of stored faces in under 1ms.
Built with .NET MAUI to share the same processing logic across Android, Windows, and cloud environments.

The hard truth is that if your biometric system can be tricked by a $20 desk printer, your entire security model is just theater.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/engineering-a-cross-platform-face-recognition-pipeline-with-anti-spoofing

Designing and Debugging CQRS Mediator Pattern Applications

Erwin Wilson Ceniza2 — Tue, 30 Jun 2026 22:50:15 +0000

I’ve definitely spent too many late nights hunting bugs in 2,000-line service classes where a "quick fix" to a GET request somehow managed to break the entire database write logic. It’s a nightmare we’ve all seen as projects scale and the "fat service" layer starts to rot.

This article walks through moving away from that "monolithic service hell" by implementing CQRS and the Mediator pattern in .NET 9. It uses the CloudPallet WMS (a production warehouse system) as a case study for keeping enterprise codebases modular and actually debuggable.

Separation of concerns across 80+ unique command files and 50+ query files, each with a single, isolated handler.
Swapping out bloated WarehouseService implementations for MediatR handlers to eliminate cascading regressions.
Leveraging .NET 9 and ASP.NET Core to build read-optimized projections that stay completely decoupled from domain entities.
Enforcing strict return types like Unit, Guid, or specific DTOs to ensure side-effect purity in every operation.
Designing denormalized read models for performance while keeping the write-side (Commands) strictly normalized.
Streamlining the debugging workflow within Visual Studio to navigate the decoupled architecture without getting lost.

At the end of the day, the biggest win isn't just the clean architecture—it’s finally being able to open a PR without worrying about breaking a feature three folders away.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/designing-and-debugging-cqrs-mediator-pattern-applications

Monolith vs Microservices: A Real-World Architectural Autopsy

Erwin Wilson Ceniza2 — Tue, 30 Jun 2026 22:48:25 +0000

I’ve spent way too many late nights arguing about whether a "legacy" monolith is actually the problem or if we’re just chasing shiny objects. It feels like the industry is finally moving past the "microservices for everything" hype and getting back to strict pragmatism regarding what actually makes sense for the budget and the team.

This article walks through a forensic comparison between two real-world production codebases—SmashElite and Drobble—to show exactly how they stack up when things get complicated.

SmashElite runs as a streamlined monolith using Express.js and TypeScript, managing 18 different route modules (like shop, courts, and forums) in a single Node.js process.
The monolith setup utilizes React 19 and Prisma ORM, bundling the entire stack into one Docker container for dead-simple deployments.
Drobble takes the distributed route with 8 independent .NET 9.0 microservices, each assigned to dedicated ports like 5297 for UserManagement and 5059 for Orders.
It implements a database-per-service pattern, mixing PostgreSQL, MongoDB, and Elasticsearch based on the specific needs of each service.
Event-driven communication is handled via RabbitMQ and MassTransit, adding significant async complexity compared to the monolith’s direct function calls.
The operational footprint jumps from a single docker-compose service in the monolith to over 13 total containers for the microservices infrastructure and API gateway.

The biggest takeaway is that while microservices solve organizational scaling issues, they'll absolutely murder your productivity if you're a small team just trying to ship features.

Read the full article here:
https://erwinwilsonceniza.qzz.io/blogs/monolith-vs-microservices-real-world-autopsy