I enjoy building products where frontend, backend, design, and product thinking come together.

Most of my work starts with a simple question: what problem are we actually trying to solve?

From there, I like following the whole product journey: turning a design into a responsive interface, defining application logic, working with APIs and data, handling edge cases, and eventually shipping something people can actually use.

I care about clean structure, maintainable code, thoughtful UX, and the small details that make software feel finished.

const kamy = {
    name: "Kamyar Zamanfar",
    role: "Full-Stack Developer",
    location: "Germany 🇩🇪",

    workingWith: [
        "React & Next.js",
        "Angular",
        "TypeScript & JavaScript",
        "Node.js & REST APIs",
        "PostgreSQL & Supabase",
        "Figma & Design Systems",
        "AI Integrations"
    ],

    interestedIn: [
        "Full-Stack Product Development",
        "Frontend Architecture",
        "Developer Experience",
        "AI-Powered Products",
        "Clean & Maintainable Systems"
    ],

    principles: {
        code: "Make it understandable before making it clever",
        product: "Solve the real problem",
        design: "Details are part of the experience",
        growth: "Build, review, learn, repeat"
    },

    currently: "Building real products and getting better with every iteration"
};

My interest in technology started with video games.

At first, I was simply curious about how they worked. How does an interface react instantly? Where does all the data come from? How do hundreds of systems work together without the user thinking about any of them?

That curiosity eventually moved from games to interfaces, from interfaces to programming, and from programming to understanding complete software systems.

Frontend was my starting point because I liked seeing ideas become interactive experiences.

But while building frontend applications, I kept asking questions:

• Where does this data come from?
• How should it be structured?
• Who validates it?
• What happens when something fails?
• How should the frontend and backend communicate?
• How do we keep the application maintainable as it grows?

Those questions naturally pushed me further into backend development, databases, APIs, architecture, and eventually full-stack development.

Today, I enjoy understanding and building the complete path from idea → design → interface → logic → data → working product.

One of the projects closest to me is Heldio, an AI-powered language-learning product.

The idea comes from a real problem: learning a language is very different from actually being able to use it in daily life, at work, in meetings, or in unfamiliar situations.

Heldio explores how AI, structured learning, contextual practice, feedback, and progress tracking can work together to create a more useful learning experience.

For me, it is also a place where several things I care about meet:

product thinking, UX, software architecture, full-stack development, and applied AI.

I also work on full-stack applications and team projects involving things like:

• responsive interfaces
• reusable component systems
• Figma-to-code implementation
• state management
• CRUD workflows
• REST APIs
• authentication
• relational data
• Git branches and pull requests
• code reviews
• testing
• deployment

I especially enjoy projects where I can understand more than just my own component and see how the different parts of the system fit together.

const buildProcess = {
    understand: "Understand the problem before choosing the solution",

    plan: "Keep responsibilities and boundaries clear",

    design: "Build around the user flow, not just the screen",

    frontend: "Reusable components, predictable state, thoughtful UX",

    backend: "Clear contracts, sensible data models, explicit error handling",

    teamwork: "Small branches, focused commits, useful reviews",

    ship: "Test it, review it, deploy it",

    improve: "Learn from what happens after shipping"
};

I don't think good engineering means making everything complicated.

Usually, I prefer the solution that is easier to understand, easier to test, easier to maintain, and still leaves room for the product to grow.

Good software is more than a working interface.

It is the result of many small decisions about structure, behavior, performance, accessibility, data, and user experience.

Most users will never notice those decisions individually, but they will feel the difference when they are done well.

Software development changes constantly, so a large part of the job for me is continuing to learn.

Right now, I'm especially focused on deepening my knowledge of:

• React architecture and modern frontend patterns
• Next.js and full-stack React applications
• TypeScript
• Node.js backend architecture
• API design
• PostgreSQL and data modeling
• authentication and application security
• testing and debugging
• design systems
• AI integration in real products

My goal isn't to collect technologies.

It's to understand them well enough to know when they are useful, why they are useful, and when not to use them.

Build things. Understand how they work. Make the next version better.