Ubuntu
Canonical
My daily ground
I moved to Linux on desktop and server and stayed—open tooling, fewer surprises from licensing, one environment I can reason about. It matches how I like to work: own the machine, keep the stack honest.
AleHeredia
Software Engineer
My main focus is to explore the concept of elegance—where quality and simplicity meet, and value begins. I found the medium in software, by crafting behavior one line at a time.
End-to-end
The meaning of full stack
I didn't set out to collect skills across the stack, the work kept opening new areas, and I followed. That's what lets me ship end-to-end. I like getting the details right, especially when I'm carrying the whole piece.
Agile
I learned what agile can feel like at Hobsons (now PowerSchool), through Modus Create—specs-driven work, clear priorities, and time spent on purpose. People’s skills were used well; meetings and scope earned their place. It’s still the rhythm I aim for.
Design
Studying graphic design taught me to think about how things work, not just how they look on the surface. Elegance was fundamentals: name the problem, respect time and space, know the audience. The deliverables were assets; the habit was thinking end-to-end.
Cloud
I grew into cloud work by taking ownership of what ships, infrastructure from code, environments that stay in step, and attention to performance and capacity as usage grows. Running what you build keeps the feedback loop honest and the launches calmer.
Architecture
I value architecture that leaves room to grow, clear boundaries, APIs you can reason about, systems that don’t need a full rewind for every change. That came from projects where everything talked to everything; the alternative is simply easier to live with.
Data
Data work, for me, is aligning the model with how the product really behaves—documents when the shape is fluid, relations when integrity matters, pipelines and warehouses when reporting needs its own home. When the facts are solid, everything above them can move with confidence.
Applications
Applications are where the stack meets a person—UI, logic, persistence, the connective tissue in between. I’ve shipped full products long enough to appreciate code that’s clear and well maintained; that’s what I try to leave behind.
Path
Experience
Each stop here taught me something. Workflows I learned from, products I enjoyed crafting, and the gradual shift from design into software.
Alteos
Berlin, Germany
At Alteos I’m in my most productive stretch yet—and the most challenging company I’ve worked for. We’re a small engineering team behind a complex insurance model, with most of the business built and run in-house; the bar is high, and the people here earn their place. I thrive in that kind of depth—navigating complexity is exactly where I want to be.
Softgames
Berlin, Germany
Five years at Softgames on instant-games platforms—serverless architecture, infrastructure, and the full cycle from design through support. I valued the pace and the chance to own systems end to end with people who cared about the craft.
Modus Create
Remote
With Modus Create I joined a distributed team on an academic planner—designing, building, testing, and shipping embedded modules together. It was a huge leap: colleagues who respected software craftsmanship deeply, and a new benchmark for how enriching the work could feel when collaboration and care for the craft are the norm.
Mojix
La Paz, Bolivia
At Mojix I worked on hybrid apps for low-end devices—real-time RFID inventory reporting for retail. Hard constraints, careful choices, and shipping something teams could rely on in the field.
PluralSight
FormationPluralSight deepened my front-end craft—Angular, TypeScript, and patterns I still reach for when structure needs to scale with the product.
Frontend Engineer
Logus Graphics
La Paz, Bolivia
I built Logus Graphics from design into full-stack work—proposals, UX, deployment, maintenance, delivery. By 2017 software was my main craft; I still appreciate owning the whole arc for clients who trusted me with it.
Kiprosh
Remote
At Kiprosh I designed websites and dashboards and carried them through to HTML/CSS—early practice in closing the gap between mockup and something that worked in the browser.
iEstrategas
Cochabamba, Bolivia
A short stretch at iEstrategas in packaging and brand campaigns—learning how visual work lands in the world beyond the screen.
W3 Schools
FormationW3 Schools formalized what I was already teaching myself—HTML, CSS, JavaScript, and the shift from design into front-end engineering.
Web Developer
Rainmaker
La Paz, Bolivia
Rainmaker was web design and front-end development—my first sustained mix of layout craft and code in production.
Los Tiempos
Cochabamba, Bolivia
At Los Tiempos I joined the Gente team—pages aimed at a broader, more popular readership. Most of my time was operational, fitting news into established layouts, with some work extending that catalog. It was brief and mostly a transitional stop between chapters.
Ardilla Design
Cochabamba, Bolivia
Ardilla Design was a two-person studio—a close friend founded it with ambitions to stand alongside established agencies; he ran the business and I owned the creative side. We built branding and campaigns together and learned a lot from this experience.
ZIP Design
Cochabamba, Bolivia
ZIP Design was one of my first jobs while I was still studying—work for small companies abroad on menus, branding, posters, illustrations, and more. When the studio brought in someone running logo contests on Wilogo (a former brand-contest site), we won one after a few submissions—an early win that meant a lot at the time.
UPB
FormationAt UPB I graduated Cum Laude in graphic design—corporate identity, marketing, and the business side of creative work. Where I learned how visual systems carry meaning. We are a perception driven species and it is vital that we understand how others perceive us.
Bachelor of Graphic Design
San Ignacio
FormationSan Ignacio grounded me in natural sciences: math, physics, chemistry, and a habit of reasoning carefully before jumping to conclusions. But I would also highlight the school culture, which anchors their values in solidarity and empathy.
Bachelor of Natural Sciences
CBA
FormationCBA gave me a technical degree in English, but the language became my connection to knowledge. The culture behind it opened a wider spectrum of possibilities and helped me grow into someone who feels like a citizen of the world.
Technical degree in English
Values
Principles
After years on the web, these are the principles I still lean on—shaped by real projects and teams, and what helped us ship with care and keep improving together.
Ownership
I care for the full loop—deployment, performance, capacity, monitoring, support. Taking ownership early made it easier to improve things before they became incidents.
Accountability
When I had room to decide, I treated the outcome as mine—wins and lessons included. Trust grew when I followed through consistently, especially when things didn’t go as planned.
Solutions oriented
I’ve done my best work on teams that looked for a path forward together. That mindset kept collaboration kind and momentum steady, even on tight weeks.
Reuse
I focus craft on what makes a product distinctive and reach for proven patterns everywhere else. Standing on good prior work helps the team move faster without sacrificing quality.
Rapid delivery
I like shipping something real early and learning from real use. Staying close to what matters helps deliver value without piling on complexity.
Added value
Work that crossed product, business, and customer showed me how much better outcomes get with the whole picture in view. I try to leave each piece a little clearer and more useful for the next person.
Tooling
Tech Stack
These are the tools I reach for in practice—chosen for readability, sensible reuse, and ownership of what ships. From an open desktop to local models when it matters, each one earned its place by how it feels to build with.
Figma
Figma
Design with engineering in the room
Years of graphic design made me picky about how ideas are shared before they become code. Figma is where I sketch systems and handoffs without losing the thread—still thinking end-to-end, still caring about the problem first.
TypeScript
Microsoft
Clarity before scale bites
I reached for types when projects grew past what I could hold in my head. TypeScript lets me be strict where it matters and incremental where it doesn’t—closer to the elegance I want in code: readable, explicit, hard to fool yourself.
React
Meta
The UI layer I trust
React became my default after enough products where components and predictable updates mattered more than chasing the newest framework. I know its edges; I also know how to ship with it.
shadcn/ui
shadcn
Components I actually own
shadcn/ui is what I reach for now—Tailwind-native pieces you copy into the repo, not a dependency that fights your design. Radix underneath for accessibility; room above to shape the product without wrestling a theme layer.
Tailwind CSS
Tailwind Labs
Styles that stay close to the markup
Utility-first CSS clicked when I got tired of hunting across files for the one class that moved a pixel. I can iterate quickly and still keep a coherent visual language—especially on smaller surfaces I own end-to-end.
Next.js
Vercel
React, ready to ship
Next.js is what I reach for when routing, rendering, and deployment shouldn’t be a separate science project. Less ceremony, more product—aligned with shipping value early and refining in the open.
Apollo
Apollo Graph
Clear contracts between services
GraphQL with Apollo helped when several teams and services needed a shared language without welding everything together. Schemas as contracts, clients that stay in sync—fewer surprises at integration time.
MongoDB
MongoDB
When the shape is still moving
I’ve used Mongo when the domain was fluid and the document model matched how we thought about the product—not every problem is relational on day one. It earns its place when flexibility matters more than a fixed schema upfront.
PostgreSQL
PostgreSQL Global Development Group
When the facts must hold
Postgres is my default when integrity, relations, and long-lived data are the point—insurance platforms, reporting, anything where getting the facts wrong poisons everything above. Solid, boring in the best sense.
Nest.js
Kamil Mysliwiec
SOLID, built in
Nest.js is the Node framework I rate above the rest—SOLID isn’t a slogan, it’s how the codebase is shaped. Modules, injection, clear boundaries: elegant in the details and in how a backend grows without turning into a tangle of handlers.
Laravel
Taylor Otwell
Craftsmanship I don’t forget
Not my daily stack anymore—it stays for the craftsmanship behind several projects and the best PHP DX I’ve known. A pleasure to build with, and still the bar I measure everything else against.
Docker
Docker
The same box everywhere
Containers became non-negotiable once I was the one answering for deploys. Docker keeps dev and production close enough that surprises are rare—and ownership means I care that they are.
AWS
Amazon
What actually runs in production
I’ve lived on AWS through serverless work and long-running services—choosing the smallest set of services that meet reliability and cost, not the diagram with every box filled. Run what you build includes the bill.
Terraform CDK
HashiCorp
Infra beside the application
Defining infrastructure in TypeScript keeps changes reviewable and repeatable—the same habits as application code. I like when environments are code, not folklore passed between teams.
Zustand
pmndrs
State without the weight
I moved to Zustand when Redux-shaped ceremony stopped earning its keep—small stores, readable updates, less magic. Enough structure to stay honest; not so much that simple UI state feels like a framework project.
Vitest
Vitest
Tests that keep pace
Vitest fits how I work now—fast feedback, familiar API, close to Vite and modern tooling. I’m more likely to keep tests when running them doesn’t feel like a separate job.
Ollama
Ollama
Models at home
I run local models when privacy, cost, or offline work matters—experimenting without sending the codebase on a tour. It’s part of how I explore AI without handing everything to the cloud by default.
Cursor
Cursor
In the editor, every day
Cursor is where I actually write code now—context, refactors, agents in the same place I review diffs. The point isn’t novelty; it’s shortening the loop while staying responsible for what ships.
OpenCode
OpenCode
Agents in the shell
Open source, terminal-native—close to how I already work on Ubuntu. I use it when automation belongs in the shell, not in another app fighting for attention.
Codex
OpenAI
Reach when local isn’t enough
Cloud models still have a seat when the problem needs more reach or reasoning than what I run locally. I treat them as a tool, not a substitute for judgment—same ownership, same review before merge.