Your first shader is mostly boilerplate
Raw WebGL looks terrifying because of 30 lines of setup you write once; the actual shader logic is two small questions.
Writing
Notes on frontend engineering, system design, and the habits competitive programming leaves you with.
Eloquent is an ORM, not a schema designer
Design your tables like the framework doesn't exist, then let Eloquent map them—the database outlives the application code every time.
Layout, paint, composite: why transform is cheap and top is not
Transform and opacity animations skip the expensive stages of the rendering pipeline; top and left animations pay for all of them, every frame.
useEffect is not a lifecycle
Effects synchronize your component with external systems. Most of the effects people write shouldn't exist at all.
Stop splitting your monolith too early
Why monoliths aren't shameful, what microservices actually cost, and the one real reason to split.
The service layer is not optional
Fat controllers are the first technical debt you accumulate. They're also the most expensive to pay back later.
N+1 queries are a symptom, not the disease
Fixing the symptom with a quick with() call is fine. Understanding why you wrote it again next week is better.
TypeScript as documentation, not a safety net
Types disappear at runtime. The real value of TypeScript is what it communicates to the next developer—including future you.
React is not your application
React is a rendering library. The moment business logic lives in components, you've given it a job it wasn't designed for.
Auth is the one thing you don't wing
Every other architectural decision can be refactored later. Authentication mistakes follow you forever.
The CTO title means nothing if you stop building
Technical leadership without technical grounding is just management with a fancier hat.
Index everything? Index nothing? Here's what actually works
Indexing is one of those things everyone knows they should do and almost nobody does systematically.
Docker is not a deployment strategy
Docker solves packaging. Running software reliably in production requires answers to questions Docker doesn't ask.
JWT vs sessions: there is no universal answer
The right auth mechanism depends on what you're building. Here's how to think about the tradeoff.
State management doesn't have to be this complicated
Before you reach for Redux, ask whether you actually need it. Most apps don't.
Laravel's queue system changed how I think about time
Synchronous thinking is the default. Queues rewire your brain to think about what actually needs to happen right now.
The fastest way to learn a codebase you didn't write
Don't start with the models. Start from the entry points and follow the data.
YAGNI: the principle I needed at 19
You Aren't Gonna Need It. The hardest part isn't following the rule—it's believing it applies to your brilliant future requirement.
Hash maps changed the way I see every problem
O(1) lookup is one of the most powerful ideas in programming. Once you internalize it, you see opportunities everywhere.
Form requests saved my codebase
Inline validation in controllers is a mess waiting to happen. Form Request classes are the clean alternative.
Building Redblock: what multiplayer game dev taught me
Redblock Online was a browser-based multiplayer aim trainer. Building it taught me more about performance and real-time systems than any tutorial.
CI/CD doesn't have to be complicated on day one
GitHub Actions, run tests on push, deploy on merge to main. That's 80% of what you need.
Building Phende: why I built a CRM for developers
CRMs are built for salespeople. Phende is built for developers who want to automate everything in code.
The event loop is not magic
setTimeout(0) has surprised every JavaScript developer at least once. Here's what's actually happening.
Designing APIs that don't embarrass you in two years
API design decisions are among the hardest to reverse. Get the basics right from the start.
Soft deletes are a trap
Soft deletes seem like a safe default. They're actually a source of subtle bugs that follow you forever.
Why you probably don't need Redis yet
A deep dive into aggressive database caching techniques that can defer your infrastructure complexity.
Senior doesn't mean you stop writing code
The promotion to senior or lead can be a trap. Stay in the code or slowly lose what made you good at the job.
The mindset of competitive programming in real-world apps
How solving math puzzles under a time limit makes you a better software engineer when building products.
Git workflows that actually scale with your team
Trunk-based, feature branches, git flow—the right choice depends on your team size and release cadence.
JavaScript closures explained by someone who actually uses them
Closures aren't a trick question in a job interview. They're one of the most useful features of the language.
Rate limiting is not optional
Unprotected endpoints are an invitation. Brute force, scraping, and accidental floods are preventable.
MVPs that survive contact with users
An MVP isn't a half-built product. It's a complete product with a narrow scope.
Microservices are a people problem
Conway's Law says your architecture will mirror your organization. The best time to split a system is when your team forces you to.
When to denormalize (and when it's just laziness)
Denormalization is a deliberate tradeoff, not an excuse to skip proper schema design.
The browser is smarter than you think
Before you reach for JavaScript to solve a problem, check whether the browser already solves it for you.
Why I still reach for vanilla CSS sometimes
Tailwind is excellent. It's also not always the right tool. Some things CSS does better on its own.
Database migrations as a first-class concern
A migration that breaks in production is worse than a feature not shipped. Treat migrations with the same care as your code.
CSRF, XSS, and the attacks developers still ship
These attacks are two decades old. They still get through code review. Here's why.
The product decisions that haunt you
Technical choices become product constraints. The ones you made at 2 AM six months ago are now the ceiling of what's possible.
async/await made me a worse programmer (briefly)
async/await is great syntax. It hides complexity that you still need to understand.
Binary search is everywhere, you just don't see it
Binary search isn't just an interview question. It shows up in databases, debugging workflows, and real production systems.
Component libraries vs. building your own
Shipping a third-party component library is fast. Owning it long-term is expensive. Here's how to think about the tradeoff.
How understanding TCP made me a better web developer
HTTP runs on TCP. Understanding what TCP does (and what it costs) explains why the web works the way it does.
From Cuba to Barcelona: what changed and what didn't
Building software under resource constraints teaches you things that abundance doesn't. Some of those lessons still shape how I work.
The right amount of infrastructure for a new project
One VPS is fine. You don't need Kubernetes, you don't need three environments, and you probably don't need managed everything.
When to reach for a framework and when to stay vanilla
Every framework solves the same set of problems. The question is whether you have those problems.
What I've learned building internal tools
Internal tools are products too. They just have a more forgiving user base—until they don't.
Recursion made simple by someone who struggled with it
Recursion clicked for me when I stopped thinking about the whole problem and started thinking about one step.
Why I still practice algorithms as a CTO
Staying sharp isn't about interview prep. It's about keeping the muscle memory for clear thinking.
Environment variables in your repo: the gift that keeps taking
Committing secrets to your repository is a mistake that follows you. Git history is forever.
Refactoring legacy code without rewriting it
The rewrite instinct is almost always wrong. Small, safe changes with tests are almost always right.
The HTTP request lifecycle you should actually understand
From the moment you hit Enter to the moment the page renders, a lot happens. Most web developers don't know half of it.
What competitive programming actually teaches you
It's not about the algorithms. The algorithms are just a vehicle for developing a specific way of thinking under pressure.
Clean code is not a religion
Clean code principles are guidelines, not commandments. The goal is working software that can be maintained, not code that passes a style audit.
What happens when you own the whole stack
Full-stack development isn't just knowing both frontend and backend. It's understanding how the decisions in each affect the other.
The debugging workflow that actually works
Good debugging is a systematic process, not a vibe. Here's how to find any bug faster.