Contenido

TECHNICAL_LOGS // CODE RECIPES & SOLUTIONS

Practical Architecture & Code Recipes.

I believe the best way to build software is to clearly document, teach, and unblock the team. Here are real-world playbooks explaining why and how specific technical decisions solve critical business bottlenecks.

⚡ Technical Questions

Stuck on a tricky relational model, WebSockets latency, or n8n AI workflow? I help developers unblock technical bottlenecks and help teams implement clean production standards.

ASK A TECHNICAL QUESTION ↗
// INFRASTRUCTURE TIP

Where to Deploy: Stop Using Shared Hosting for Real Backends

Shared hosting terminates long-lived WebSocket connections, limits background workers (Celery), and blocks root access. When building serious software, I teach my teams to deploy containerized services on a dedicated Cloud VPS like DonWeb.

PROMO CODE: regalo-blas-arjona-m20nrl (Up to 60% OFF first purchase)
LESSON 01 // ARCHITECTURE PATTERN REAL-TIME COURIER GEOLOCATION

How to Build Real-Time Delivery Tracking Without Google Maps Pricing

The Problem: Google Maps charges per API call. If 10 couriers broadcast coordinates every 3 seconds to hundreds of active customers, monthly bills escalate uncontrollably.

The Concept: Decouple the map renderer from the real-time pipeline. Use OpenStreetMap with Leaflet.js on the frontend and maintain a lightweight WebSocket server in Node.js to stream coordinates. Zero tile billing.
// Library Breakdown:
  • Leaflet.js: 40KB JavaScript mapping library. Extremely performant on low-end mobile devices.
  • OpenStreetMap Tiles: Free tile server layer operated by the open-source community.
  • navigator.geolocation.watchPosition(): Native browser API polling GPS chip changes automatically.
  • WebSocket (ws): Full-duplex connection bypassing costly HTTP polling overhead.
tracker_client.html (Interactive Implementation)
<!-- Load Leaflet CDN without heavy bundle overhead -->
<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
<script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>

<div id="map" style="height: 380px; width: 100%; border-radius: 8px;"></div>

<script>
  // Step 1: Initialize Leaflet canvas centered on initial coordinates
  const map = L.map('map').setView([-24.7859, -65.4117], 14); // Salta, Argentina
  
  // Step 2: Use free OpenStreetMap tile server (zero cost)
  L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
    attribution: '© OpenStreetMap contributors'
  }).addTo(map);

  const courierMarker = L.marker([-24.7859, -65.4117]).addTo(map);

  // Step 3: Stream coordinates via WebSocket channel
  const socket = new WebSocket('wss://api.yourdomain.com/ws/tracking/courier_12/');
  socket.onmessage = (event) => {
    const { lat, lng } = JSON.parse(event.data);
    courierMarker.setLatLng([lat, lng]);
    map.panTo([lat, lng]); // Smooth camera centering
  };
</script>
LESSON 02 // DATA MODELING & INTEGRITY FINANCIAL LEDGERS & STATE MACHINES

Architecting Automated Late-Fee Penalties in Real Estate Systems

The Problem: When property managers calculate late fees manually in spreadsheets, rounding errors and human discrepancies trigger friction between landlords and tenants.

The Concept: Never calculate financial penalties on read-time or client-side. Use Pessimistic Row Locking (`select_for_update`) inside an atomic transaction via Django ORM and PostgreSQL's exact DecimalField to ensure ACID compliance.
// Architecture Components:
  • transaction.atomic(): Guarantees that if any step fails, the entire database transaction rolls back.
  • select_for_update(): Locks the specific database row to avoid race conditions from concurrent payment attempts.
  • DecimalField: Eliminates floating-point calculation errors native to standard double/float types.
contracts/services.py (Atomic Penalty Computation)
from decimal import Decimal
from datetime import date
from django.db import transaction

def compute_overdue_penalty(lease_payment_id: int):
    # Lock row at DB level until calculation finishes
    with transaction.atomic():
        payment = LeasePayment.objects.select_for_update().get(id=lease_payment_id)
        
        if payment.is_settled:
            return payment.total_due

        today = date.today()
        if today > payment.due_date:
            days_overdue = (today - payment.due_date).days
            daily_rate = payment.contract.daily_penalty_rate # e.g. 0.002 (0.2%/day)
            
            # Use Decimal math for strict bank-grade precision
            penalty = payment.base_amount * Decimal(days_overdue) * daily_rate
            payment.penalty_amount = penalty
            payment.total_due = payment.base_amount + penalty
            payment.save(update_fields=['penalty_amount', 'total_due'])
            
        return payment.total_due
LESSON 03 // FULL-STACK CONCURRENCY APPOINTMENT LOCKS & COMMISSION SPLITS

Preventing Double-Bookings & Automating Commission Splits for Salons

The Problem: Barbers and stylists often get double-booked when two clients hit "confirm" simultaneously on their phones, and calculating manual end-of-day commission cuts creates staff tension.

The Concept: Don't handle slot collisions solely in application logic. Enforce PostgreSQL EXCLUDE USING gist range constraints directly in the database engine, and compute commission cuts as an immutable transaction event upon checkout.
// Stack & Tooling:
  • React + TypeScript: Strongly typed order interface preventing invalid data propagation.
  • Zustand: Lightweight reactive store managing the daily cash drawer with minimal re-renders.
  • PostgreSQL Range Exclusion: Hard mathematical guarantee that no overlapping appointment timestamps exist for the same staff ID.
checkout_commission.ts (Commission Split Recipe)
interface ServiceOrder {
  orderId: string;
  barberId: string;
  servicesTotal: number;
  commissionPercentage: number; // e.g. 50%
}

// Pure function: predictable, testable, zero side-effects
export const settleOrderCommission = (order: ServiceOrder) => {
  const barberPayout = (order.servicesTotal * order.commissionPercentage) / 100;
  const venueRevenue = order.servicesTotal - barberPayout;

  return {
    orderId: order.orderId,
    barberPayout,
    venueRevenue,
    settledAt: new Date().toISOString()
  };
};
LESSON 04 // DECENTRALIZATION & WEB3 TRUSTLESS ESCROW IN SOLIDITY

Building a Trustless Escrow Smart Contract in Remix IDE

The Problem: When peer-to-peer transactions occur in marketplaces or auctions, neither party trusts the other to send payment or goods first without an expensive bank or broker fee.

The Concept: Replace the middleman with immutable code. Using Solidity, we hold collateral funds in contract bytecode and only release them when cryptographic verification of delivery is signed by the buyer.
// Development Tooling:
  • Remix IDE: In-browser Ethereum VM sandbox for compiling, unit testing, and debugging contract state before mainnet deployments.
  • Solidity ^0.8.20: Enforces automated overflow/underflow checks and strict address casting.
EscrowGuard.sol (Clean Solidity Implementation)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract EscrowGuard {
    address public buyer;
    address payable public seller;
    uint256 public amount;
    bool public isDelivered;

    // Buyer locks collateral amount upon instantiation
    constructor(address payable _seller) payable {
        buyer = msg.sender;
        seller = _seller;
        amount = msg.value;
    }

    // Only buyer signature unlocks funds to seller
    function confirmDelivery() external {
        require(msg.sender == buyer, "Only buyer can confirm delivery");
        require(!isDelivered, "Funds already released");
        
        isDelivered = true;
        seller.transfer(amount);
    }
}
OPEN_SOURCE // CONTINUOUS_LEARNING

Looking for more libraries, architecture recipes, or technical docs?

This knowledge base is constantly expanding with battle-tested snippets, backend modules, and architectural breakdowns. Check out more open repositories, boilerplates, and code implementations on my GitHub, or reach out directly for a custom solution.

🇦🇷 ¿Estás en Argentina? Podés ver este contenido en Español.
Scroll al inicio