Hi! I'm Ismoiljon — a software engineer from Uzbekistan, walking my own path in technology: quietly, curiously, and always all the way to something real.
If you ask me what I do, the honest answer is simple: I build. Not because someone assigns it to me, but because an idea shows up in my head and quietly refuses to leave until it exists somewhere outside of it. Most of what I've made started exactly like that — a random thought while walking, a "wouldn't it be cool if...", a little itch that wouldn't go away. Then one day it has a name, an interface, users, and a story.
Some people meet their work as an obligation and spend years looking for an escape from it. I was lucky enough to meet mine as a playground — the kind where curiosity sets the rules, every finished thing unlocks three new questions, and "I wonder how this works" is a perfectly acceptable reason to stay up late. That's still true on my best days and even on my worst ones.
Nobody in my world handed me a laptop and said "become an engineer". It started the way these things usually start — pure curiosity. I wanted to know what was behind the screen. How does a website remember things? Why does one app feel alive while another feels dead? What happens when you press Enter?
I never really stopped asking those questions. Somewhere along the way the questions turned into late nights, broken builds, small victories, and the specific kind of happiness you feel when something you imagined starts working for real. If you know that feeling, you already understand half of who I am.
There was no map for any of it. No plan handed down, no guaranteed path — just a stubborn belief that if I kept following the questions one step at a time, the road would build itself underneath me. It did. Not smoothly, not quickly, but honestly: every wrong turn taught me something a shortcut never would have, and every wall I hit turned out to be a door once I stopped pushing and started learning.
The first time I made a machine do something it had never done before, I laughed out loud, alone in the room. My exact words were, "wait — it listened to me?" That little sentence rewired something big in me. The screen stopped being a window to look through and quietly became a door to walk through — and I've been walking through it ever since, still half-smiling at the same miracle.
The early chapters were ninety percent failure wearing a dramatic costume. Nothing worked, everything crashed, and error messages became my first foreign language. Somewhere in those days I wrote a line into my notebook that still makes me smile: "every error message is a letter addressed specifically to you." Corny? Completely. True? Even more so — each one turned out to be an invitation to understand things one level deeper than I thought I needed to.
The people around me sometimes asked, with honest love: "Hasn't all of this been built before?" And honestly — almost everything has. Nothing I make is the first of its kind. Telegram wasn't the first messenger either; probably not even the hundredth — and yet there it stands, alive and loved. Because "someone already did it" was never the point. The whole point fits into four quiet words I carry everywhere: "but I haven't built mine yet." That one sentence is how I learn, how I grow, and why I keep building — not to be first in the world, but to become fuller in myself.
Ideas are cheap — everyone has them. What I care about is the walk from "I have an idea" to "here, try it". Sketching it out, cutting away everything unnecessary, building the first ugly version, then slowly shaping it into something that feels effortless to use.
I like carrying an idea through its whole life: the first sketch, the first working version, the awkward middle phase nobody photographs, and finally the polished thing that ships. Some people love the beginning and get bored near the end. My favorite part is precisely that end — when the rough edges disappear and the thing starts to feel inevitable, like it could never have been any other way.
And I'm fast at this part — not careless-fast, but momentum-fast. When an idea grabs me, the first clunky working prototype usually exists within days, because I'd rather argue with something real on the screen than with an imaginary version in my head. A rough thing you can click tonight teaches you more than a perfect plan you'll finish next month. The trick is knowing that speed is for the beginning and patience is for the ending — and never swapping them.
And yes — part of the job is burial. Not every idea deserves to live, and pretending otherwise is how good energy gets wasted. I've learned to love my ideas enough to be honest with them: some get built, some get parked, and some get a proper goodbye so the next one can breathe. Choosing well between those three fates is, I think, one of the quiet skills nobody puts on a resume.
an idea isn't real until someone can touch it.
I take the things I make personally. Not in a stressful way — in a caring way. If a button is in the wrong place, I feel it. If a page loads slowly, it bothers me even if nobody complained. If someone uses something I built and doesn't notice any of the work behind it — good. That invisibility is the point.
I also believe in finishing. A finished small thing beats an abandoned big thing every single time. So I ship: real products with real links, deployed, documented, alive — not screenshots of concepts that died in a folder called "someday".
The other half of work, the part people talk about less, is trust. Trust is built in boring moments: saying honestly what's done and what isn't, giving bad news early instead of late, estimating with room for reality, and treating other people's time like it costs something — because it does. None of that shows up in demos, but every good team runs on it.
Tutorials never taught me much — building did. When I want to understand how something works, I rebuild it myself from zero: a note-taking app with a living graph of connected thoughts, a social map wrapped around the planet, assistants that quietly do boring work for people. Each one started as a question and ended as a lesson.
Hackathons accelerated everything. There's something special about a ticking clock, a team, and a deadline breathing down your neck while imagination tries to become real — I've been lucky enough to win some of them, but the real prize was what each marathon left behind: speed, judgment, and quiet proof that I can deliver when it counts.
What I love most about learning this way is that knowledge arrives attached to memories. I don't remember chapters; I remember problems — the graph that wouldn't behave, the login flow that fought back at midnight, the map that finally spun for the first time. Those stories are stitched into me now, which means the lessons are too. That's why my advice to anyone starting out is always the same: don't collect courses like trophies — pick one small thing that annoys you, and build it out of existence.
A lot of what I've made started alone at a desk, but the moments I'm proudest of happened next to other humans — hackathon teammates running on enthusiasm and questionable amounts of coffee, friends testing early versions and telling me the truth, strangers on the internet using something I built in ways I never predicted. Building alone taught me independence; building with others taught me scale. I want both in my life.
In a team I'm the person who listens before proposing, writes things down so nobody has to hold the whole project in their head, and prefers asking one clarifying question today over discovering a misunderstanding next week. I give honest feedback softly and receive it gratefully — being wrong out loud is the fastest way I know to become right.
When I mess up, and I do, you'll hear it from me first: what happened, what I learned, what changes tomorrow. I'd rather be briefly embarrassed than quietly unreliable. And when someone else stumbles, I'm interested in the fix, not the funeral — teams where mistakes can be spoken out loud are teams that move fast without breaking each other.
Everyone knows the line. In the movies, an uncle pulls his nephew aside and says it plainly: "with great power comes great responsibility." The world adopted it as a warning — once you become strong, talented, or trusted, you'd better behave accordingly.
I felt the truth of it the first time something I built escaped my own hands and landed in somebody else's day. When your work holds another person's time, trust, and attention, care quietly stops being optional — it becomes the job description. Power without that kind of care is just noise wearing a cape.
But here's what I discovered on my own path — and to be clear, the famous line isn't wrong at all; it's simply the second half of a conversation that also has a first half. In my life, power rarely arrived first. What arrived first was responsibility: family members and close relatives who quietly count on you, people who hand you their trust long before there's anything to prove, and the promises only you remember making.
And every single time I carried more than my share, I walked out stronger than I walked in. So the sentence reads true from both ends, like a road you can travel in either direction: "with great responsibility comes great power" is my half of it — not a correction, but a companion truth. Responsibility isn't only the bill you pay after receiving power; it's also the seed you plant to grow it. Take the weight first, and the strength arrives on schedule.
I believe in honesty over branding, so here it is: I'm impatient — wonderfully useful on deadlines, occasionally exhausting on waiting rooms. I fall in love with new ideas faster than I should, which means saying "no" is a muscle I train deliberately. And I'm still learning that rest isn't stolen from the work — it's part of the work; sunsets exist for a reason.
curious by default, careful by craft.
People sometimes assume that someone who builds software spends every waking hour staring at a screen. My days say otherwise. Away from the keyboard, I draw — nothing grand, mostly whatever caught my eye that morning. Drawing quietly trains the exact muscles I use in my work: noticing details, balancing proportions, knowing when a line is honest and when it's trying too hard. A sketch doesn't compile, doesn't crash, doesn't argue — it just waits patiently until you see what it wants to become.
I also carry a notebook everywhere, and it works as a second brain. Long lists, half-sentences, little diagrams that make sense to no one but me — pages where my head gets to unload. Organizing thoughts on paper is how I actually think: an idea feels completely different once it's out of your skull and sitting in front of you, crossable and improvable. Some projects you'll find on this site began as ugly doodles and messy bullet points in that notebook.
And then there's nature — real, offline nature. I'm a hopeless fan of sunrises and sunsets. A sunrise before a long day feels like the world's quietest pep talk; a sunset after shipping something feels like applause. The sky runs the most reliable release cycle I've ever seen: it never rushes, never skips a show, and still delivers beautifully twice a day. Watching it resets something in me that no screen ever could.
All of this connects to a quiet dream I keep coming back to: little assistants that take care of the boring scaffolding of an ordinary day — plans, reminders, small repetitive decisions — so mornings can stay slow, notebooks can stay full, and sunsets can be watched properly instead of being photographed through a window. That dream is half the reason I build the things I build.
And here's the part I mean the most: even with all these escapes, coding never became a chore. Sitting down to build still feels like play — the good kind, the kind where hours disappear and dinner gets cold. Drawing, writing, walking, watching the sun do its thing — none of it pulls me away from the craft. It all feeds back into it, and then I return to the keyboard genuinely excited to make something new exist.
Maybe you came here from a job application, wondering what kind of person is behind the portfolio. Maybe you're another developer comparing scars and stacks. Or maybe you just wandered in from somewhere and stayed for the sunsets. Either way — thank you for reading this far; attention is the rarest currency online, and I don't take yours lightly.
If you're hiring: what you've read is the honest version of me — someone who cares loudly, finishes quietly, and treats your product like it has his name on it. These days my time mostly passes in Python and JavaScript, but the toolbox was never the interesting part; the interesting part is what gets built with it, and who it gets built with.
If you're a fellow builder: I hope something here made you want to go start that thing you've been postponing. And if any of this resonated — whether you're hiring, building, or just exploring — I'd genuinely love to talk. You'll find ways to reach me on the home page. The inbox is open, the kettle is ready, and the next idea is already tapping its foot.