Resolving an Invoice Number Collision in an E-Invoice Integration
Two workers produced the same invoice number in production. A log of how I resolved the race condition vs. legal gap dilemma in a real project.
All posts
Category
Journal
Posts on real project experience, integrations and the career journey.
This category has 37 posts.
AI-assisted self-review — what it speeds up, where it falls short
Three months ago I built a tool to audit my own diffs. This post is not about the 'why' but the 'how much': which workflow layers it plugs into, the numbers behind the speedup, the bug patterns it keeps catching — and where it hits its limits.
Asking a Tool to Review My Own Diff — Why I Built CommitBrief
One afternoon I ran headfirst into the limits of self-review, so I wrote a tool that audits my own diff right from the terminal: CommitBrief. A note on why I built it, how it works, and what problem it actually solves.
Which Methodology for Which Project? — Notes from an 18-Year Developer
Waterfall, Agile, or Hybrid? That's the wrong question. A decision matrix from 18 years of production experience, three real case studies, and a way out of methodology religion.
Twelve Years of This Journal: Looking Back
Everything written in this journal from 2014 to 2026, and the story of growth it tells — and a closing.
Visibility: why writing is a career investment
Writing sharpens your thinking and compounds over time. On the career value of being visible — not as personal branding, but as an honest record.
Being Polyglot Is an Outcome, Not a Goal
How becoming a multi-language developer turned into a supposed goal, why it never really was one, and how I actually got there.
Eleven Years In: A Developer's Shifting Priorities
A reflection on how my priorities as a developer have shifted over eleven years of this journal — from speed to resilience, from code to decisions.
The Changing Craft of Writing Code in the Age of AI
How much of writing code have AI tools taken over, and what is left for the developer? A reflection on the shifting craft.
Mentorship and knowledge sharing: growing by helping others grow
A career post on why mentorship is not a sacrifice but one of the most effective tools for a senior developer's own growth.
From Idea to Three Platforms: My End-to-End Feature Delivery Flow
The mature, repeatable process I follow when shipping a feature across API, web, and mobile simultaneously.
Specialist or Generalist: A T-Shaped Career
On the tension between deep specialization and broad generalism, and how the T-shaped career model resolves that equation.
Managing Updates in Expo with OTA
Practical notes on shipping quick fixes without waiting for the app store review cycle, using Expo Updates — including its real limits.
Maintaining a polyglot codebase: the cost of context switching
The hidden cognitive overhead of working in multiple languages simultaneously, and how I manage it.
Building Your Own Product Solo: The Looplio Experience
An honest journal from a developer running the API, web, and mobile single-handedly — the real trade-offs of solo product development.
Shipping a Feature Across Three Layers: API, Web, and Mobile
The end-to-end workflow for delivering a single feature simultaneously across API, web, and mobile layers — lessons from building Looplio.
Home Cloud Server: Raspberry Pi 5 Upgrade
Building a home cloud server with Raspberry Pi 5: CasaOS, Nextcloud, RAID storage, and Cloudflare Tunnel.
Submitting a Mobile App to the Stores with Expo
A first-hand account of the preparation steps and real experience of submitting a React Native app to the App Store and Google Play using Expo and EAS Build.
React Native Performance: List Rendering
Practical techniques for keeping large lists smooth in React Native — real-world experience with FlatList, memo, and keyExtractor.
Side projects and open source: what they add to your career and their real cost
An honest assessment of how side projects and open source contribute to a career: the returns, the costs, and when archiving a project is the right call.
Feeding mobile and web with the same calendar logic (Looplio diary)
The practical decisions and lessons learned while consistently serving a single business logic to both React Native and web clients in Looplio.
Navigation and screen architecture in React Native
Practical decisions and screen architecture approaches for setting up React Native Navigation Stack, Tab, and Drawer structures in the context of Looplio.
The job-change decision: stay or leave
How to turn a leaving-or-staying decision from an emotional reaction into a measurable evaluation — and distinguish legitimate signals from temporary frustration.
Four Languages in One Year: The Mental Flexibility That Polyglot Practice Brings
A reflection on how moving between PHP, Go, Python, and TypeScript within a single year shaped the way I think about software.
Filtering the hype: you don't have to learn every new technology
How to manage your learning budget against the constant pressure of new tools and frameworks — a practical approach to deciding what to learn and when.
First steps into mobile development with React Native and Expo
A web developer's experience crossing into mobile: what I learned while setting up Looplio with React Native and Expo, and how my expectations shifted.
Letter to my 2014 self: advice for the early years
Looking back at 2014, the year this journal started — what I over-prioritized, what I neglected, and what I would do differently in those early career years.
Taking AI's Impact on Coding Seriously for the First Time
I've been using ChatGPT for months, but something shifted this month — a curiosity turned into a real observation that made me question how I work.
Using ChatGPT for the First Time as a Developer
Honest first impressions from a developer after a few days with OpenAI's newly released ChatGPT: where it impresses, and where it falls short.
Seniority: The Responsibility That Doesn't Come with the Title
The title often arrives before genuine seniority does. On why seniority is not about technical knowledge, but about the capacity to make decisions under ambiguity.
Being a polyglot developer: choosing the language for the problem
Personal notes on why mastering multiple programming languages is a matter of tool selection, not identity.
Simplifying My Toolset as a Software Engineer
Reviewing my tool stack during the transition from senior to staff level, I realized fewer tools lead to clearer decisions.
Getting Started with Python: Why Yet Another Scripting Language
I explain the gap Python fills in my polyglot practice, my learning journey, and a PHP developer's perspective on Python.
First step toward polyglot: why I started learning Go
After more than a decade with PHP, why did I decide to pick up a second language — and why Go?
2018 Year in Review: Where a PHP Developer Landed
An honest look at what I learned throughout 2018, how my habits shifted, and what I want to pursue next.
Building a Calendar Events Feature with Laravel
How I built a full calendar feature in Laravel from scratch, handling recurrence rules, timezones, and date range queries end to end.
Payment Integration with Laravel (iyzico): A Real-World Experience
Real problems and solutions encountered while integrating iyzico payments into a Laravel project — things not in the documentation.