What we learn building APIs, mobile apps, AI and web platforms for SMEs across Latin America.
Streaming SSR with Suspense sends the response in pieces, not all at once: it changes when an error boundary can act and what the page can still do once the shell has already shipped.
Read →Blue-green and canary solve the same problem in very different ways. We look at which release signals, and which tooling already sitting in the cluster, decide which one to use on GKE.
Read →We took Kotlin Multiplatform into real apps and learned where sharing code actually saves work, and where it ends up costing more than two native implementations.
Read →A JSON Schema forces the shape of an LLM's response, not its content: we look at where structured mode still lets fabricated data through and what we keep validating afterward.
Read →Astro hydrates nothing by default, but it does not decide an island boundary for us either. We look at the case where hydrating a whole product card instead of one button bloated an entire catalog bundle.
Read →WorkManager does not promise to run a task when we ask for it, only within the rules Doze and App Standby impose on the system. We look at how that negotiation works and what combination of causes delayed an hourly sync to every three or four hours.
Read →Without NetworkPolicies, any pod in the cluster can reach any other with zero restriction. We walk through building a default-deny policy and what broke the first time we applied one without allowing DNS.
Read →SnapStart freezes JVM startup into a snapshot and reuses it across every new environment, but that snapshot also freezes any state meant to be unique per execution. We look at what it actually fixes and what still needs runtime hooks.
Read →Cloud Run's cold start is not a universal problem: it matters when a user is waiting on the response and almost never when the work runs in the background. We look at what controls startup time and what happened when we set minimum instances on the wrong service.
Read →Recomputing an embedding that hasn't changed gets expensive fast once traffic grows. We look at the cache key we use and what broke the first time we invalidated it wrong after editing the source content.
Read →Moving a heavy calculation to a Flutter isolate looks simple until copying the full state on every message gets more expensive than the calculation itself. Here is how we redesigned the data contract between isolates.
Read →Saving an order and publishing its event as two separate steps can quietly drift out of sync. We look at how the outbox table prevents that, and what we did when the background publisher fell behind.
Read →Testing tool calling in a notebook is trivial; wiring it to an API that mutates real data is not. We look at what we log per call so we can audit and revert when the model picks wrong.
Read →A liveness probe that depends on the database can restart healthy pods under load. Here is how we split liveness from readiness, and why lowering the failureThreshold made things worse.
Read →earliestBeginDate isn't a promise, it's just the earliest point iOS might consider your task. We look at what the system actually decides and how we design around BGTaskScheduler instead of assuming a cadence it never guaranteed.
Read →The hardest bugs when migrating to Server Components are not syntax errors: they are misplaced "use client" boundaries and state that ends up duplicated between server and client. Here is how we decide what stays on the server.
Read →A failing SQS message doesn't just vanish: it keeps getting redelivered until it blocks the queue or burns through retries. Here's how we tune visibility timeout, maxReceiveCount, and DLQ monitoring to prevent that.
Read →SwiftData cuts persistence boilerplate in new iOS projects, but gives up the fine-grained control over migrations and multiple storage configurations that Core Data still offers. We look at which projects get the switch and which still get Core Data.
Read →Before proposing a microservices migration we ask about the team, the domain's real boundaries, and how fast the business actually changes. Sometimes the right answer is to stay on the monolith.
Read →Unvalidated frontmatter fails in production the moment someone visits the broken page. We look at how Content Collections and a Zod schema move that error to build time, and why z.coerce.date() avoids the most common date mistake.
Read →Creating an order and reserving inventory across two separate services rules out a shared ACID transaction. We look at how an orchestrated saga with local steps and compensation replaces two-phase commit, and why our first event-choreographed version left us without visibility into saga state.
Read →A chunking strategy that slices paragraphs in half ruins retrieval in pgvector even when the embedding model is good. We look at splitting by document structure instead of character count, and why raising the overlap made search worse, not better.
Read →An in-memory token bucket works fine with a single process, but breaks the moment an API scales to multiple replicas: each one counts on its own and the real limit multiplies unnoticed. We look at how INCR and TTL in Redis give a shared, atomic count, and what went wrong trying GET and SET instead.
Read →A two-hundred-item LazyColumn recomposes in full when only one row changed. We look at why position-based keys and inline lambdas break Compose's skipping, and how to fix it with key, remember, and derivedStateOf.
Read →Paginating with Paging 3 and RemoteMediator over a numeric offset breaks when the backend keeps receiving inserts while the user scrolls. We look at why an id-based cursor fixes it, and what went wrong trying to deduplicate on the client instead.
Read →Standalone components declare their own dependencies right in the decorator, no container NgModule required. We look at what changes in the dependency tree, in per-route lazy loading, and what went wrong migrating a whole SharedModule in one shot.
Read →Durable Functions persists a multi-day approval flow's state through replay over an event history, so no one has to hand-write a state table.
Read →Testcontainers spins up a real Postgres container for Spring Boot integration tests. We look at what problem it solves versus mocking the repository, and what it costs in CI time.
Read →System.Text.Json can generate serialization code at compile time instead of resolving it via reflection on every cold start. We look at how it works and what broke when we mixed it with a reflection fallback under Native AOT.
Read →CPU-heavy work blocks Node.js's entire event loop even inside an async handler. We look at when to isolate it with worker_threads, how to move data without copying it, and when a separate process is the better call.
Read →We replaced a CI pipeline that applied manifests by hand with a controller that syncs the cluster against git and detects drift on every reconciliation cycle.
Read →Pulling modules out of a monolith without stopping the business takes a router that decides which system handles each request, and a clear rule for what to extract first: the data boundary, not the folder structure.
Read →A dashboard full of CPU and memory graphs does not explain why one specific request was slow. We walk through configuring Micrometer with OpenTelemetry in Spring Boot 3 to export business metrics and traces that actually answer that question.
Read →We wired an LLM reviewer into our pull requests: what kind of findings we trust it with, and why architecture decisions stayed out of its reach.
Read →A manual change in the AWS console leaves Terraform's state out of sync, and the next apply silently reverts it. Here's how we catch that drift before it hurts.
Read →A timeout without a circuit breaker still drains threads while the external provider stays down. We look at how Resilience4j cuts off calls in time with CircuitBreaker, TimeLimiter, and a dedicated thread bulkhead.
Read →Mixing server state and client state in one Redux store forces you to sync the cache by hand. Here's how TanStack Query keeps the two apart.
Read →Cloud Tasks delivers to a single target with rate control; Pub/Sub publishes an event to any number of subscribers. We look at where each one is a bad fit in a real backend.
Read →Chaining Lambdas by events works until the flow grows: retries that redo finished steps, and nobody can tell where a case is stuck. A look at when Step Functions actually earns its place.
Read →Replacing completion handlers with async/await is not just a syntax change: it means tying every task's lifetime to the view's lifecycle. We cover Task, async let, TaskGroup, and the bug of a loose Task updating a screen that no longer existed.
Read →DataAnnotations doesn't handle conditional or cross-field rules well. How we structured FluentValidation validators and wired them into a .NET Minimal API pipeline.
Read →Low CPU doesn't mean light load: it can mean the pod is waiting on a slow downstream call while a queue backs up. How to wire Prometheus Adapter into the HPA so it scales on the right signal.
Read →The server-client boundary isn't the whole screen, it's the one piece that actually needs interactivity. The criteria we use to draw that line, component by component.
Read →A network timeout does not mean the payment failed: it can mean the client lost the response to a payment that went through. How to implement an idempotency key in Spring Boot that covers that case, not just the duplicate charge.
Read →The concrete problems with Provider that pushed us to Riverpod: BuildContext coupling, implicit providers that are hard to test, and a real provider migrated end to end.
Read →We compare Cloud Run and GKE Autopilot on what actually changes an architecture decision: cold starts, networking control, and the point where a cluster starts to earn its keep.
Read →SSE handles a large share of real-time updates with a fraction of the operational overhead of a WebSocket server. We compare data flow direction, automatic reconnection, and compatibility with existing HTTP infrastructure, with Node.js examples.
Read →Astro hydrates nothing by default: every interactive component is an explicit decision. We cover client:load, client:idle, client:visible, and the most common mistake, hydrating components that never needed client-side JavaScript.
Read →Managed Identity solves authentication between Azure resources without storing credentials, but only once you understand system vs. user-assigned identity and the RBAC errors around it.
Read →A concrete GitHub Actions pipeline to ECS Fargate: build, push to ECR, task definition updates, and a rolling zero-downtime deploy, with OIDC, health checks, and automatic rollback.
Read →pipe() respects data-flow backpressure, but not error propagation or a Transform that buffers chunks on its own. We look at why that saturates an ingestion microservice's memory and how pipeline() fixes the lifecycle.
Read →GlobalScope has no lifecycle, and that is exactly what causes the leak. We walk through the Job hierarchy, the real difference between lifecycleScope and viewModelScope, and how a misused SupervisorJob can hide exceptions.
Read →Swift's @Observable macro tracks state at the property level, not the object level. We cover the real impact on view recomposition and when to use @State vs @Bindable.
Read →Minimal APIs strips away ceremony, but it won't organize your project for you. We cover grouping endpoints, where validation filters belong, and when it's time to go back to controllers.
Read →Without a readinessProbe and a startupProbe, a pod can look healthy and still cause 502s on every rolling deploy. We cover the three probes, their defaults, and how to size them for slow JVM and .NET startups.
Read →Signals does not replace RxJS, it solves a different problem. We cover when to use each, how they interoperate through toSignal and toObservable, and the anti-patterns we keep seeing when teams port RxJS-heavy code.
Read →LLMs generate methods, imports, and parameters that sound real but do not exist. We walk through the five signs that give away a code hallucination before it costs hours of debugging.
Read →How we structure mid-to-large Flutter projects by feature, using Cubit for state and get_it for dependency injection. With code, decision criteria, and the mistakes that break the separation in practice.
Read →An LLM can write code that compiles and passes its own tests without that meaning it is ready to ship. Here are the four checks we run before the client sees it.
Read →Most projects don't need microservices yet. We walk through what they actually cost and the five objective signals that genuinely justify splitting the monolith.
Read →Nine articles describing failures in our own product. It is not humility: it is the only way a good number means anything.
Read →No test covers the scenario where your program is not running. And that turned out to be one of our most expensive failure modes.
Read →If the shape of Cerberus is what loses money, a system with the opposite shape should make it. We built it. The result was a profit factor of 1.04 over seven and a half years: a coin flip.
Read →The URL you compile into the binary is immutable for life: the client pastes it once and never touches it again. That constraint decides the whole architecture.
Read →We lowered the limit from $60 to $20 expecting less risk. Maximum drawdown went from $224 to $2,331. A stop inside normal market noise does the opposite of what you think.
Read →Most robots mix entry logic with protection logic. When the strategy fails, the protection fails with it. Here is how we split the two.
Read →Every close attempt we sent was rejected. The lesson: if your protection lives only in your code, it does not exist when you need it most.
Read →Same configuration, same data, same window. Only the simulator fill model changes. And the result changes sign. A backtest like that cannot support any decision.
Read →The reference bot we studied closed almost 99 % of its cycles green. It also carried $64,077 of floating loss. A high win rate is not an edge: it is a knob you can turn.
Read →A volatility brake, a flip-close and a regime switch. All three sounded good. All three came out worse than not having them. This is what happens when you measure one at a time instead of stacking.
Read →The real workflow for integrating Claude into daily development: planning, block-by-block generation, diff review, tests with real semantics, and documentation. No hype — what actually works.
Read →Java 21 shipped stable virtual threads and Spring Boot 3.2 enables them with one line. What actually changes in your API, what doesn't, and the pinning problem nobody tells you about.
Read →Not every project needs microservices from day one. The modular monolith solves the real problems of the traditional monolith without microservices' operational complexity — and keeps the door open to migrate later.
Read →The architecture decisions you make in the first few weeks determine how much the project hurts at month 6. How to organize domain modules, separate layers, and keep clean boundaries in NestJS.
Read →AI-generated code can look perfect and still break production. This checklist covers the 6 points you need to verify before approving any LLM-generated PR.
Read →AI can refactor code with precision, but it can also silently break production. Here are the types of changes where you can trust it — and where you need to verify carefully.
Read →Tuurt builds custom software, integrates AI where it adds verifiable value, and develops 2D and mobile games. This is what you will find in this blog and how we work.
Read →AI-generated code usually compiles and fails code review. The difference is not in the model — it is in how you describe the work. Five concrete practices that move the needle.
Read →