Rizmajer Máté Levente

The smallest structure that carries the job. I add an abstraction when the second caller appears — before that, an interface with one implementation is not an abstraction, it is an extra file.

• A fact lives in one place and everything else reads it from there. This site learned that the expensive way: the number of projects lived in four files at once, until one of them rotted into a false claim.
• Shared decisions — motion timings, route paths, colour tokens, bilingual copy — live in their own modules, so they cannot quietly drift apart.

One component per responsibility, shared behaviour in hooks. State lives where it is used, and anything derivable is not stored — the language, for instance, follows from the URL rather than from state.

• Every asynchronous path has a loading, an error and an empty state, not just the happy one. An empty state is copy too, not a gap where a box should be.
• Accessibility is not a layer added afterwards: a visible focus indicator on every interactive element, measured contrast rather than assumed contrast, and a static page when the visitor has asked for reduced motion.
• Responsive work starts at the phone, because that is where most visitors arrive from — not at the wide viewport the developer happens to be sitting in front of.

REST endpoints organised by resource, with predictable status codes and error responses shaped like the successful ones — so the client does not need two ways of reading the same call.

• Validation runs on the server as well. Checking in the browser is a convenience for the user, not a defence for the system.
• Authentication and authorisation are two questions, not one: who you are, and what you may reach. Collapsed into a single role field, the second one can never be answered precisely.
• Choosing the schema is a decision, not a habit: relational where the shape of the data is fixed, document-based where it is not. Changes go through migrations so they stay traceable.

Quality is not a phase at the end. Lint and tests after every change, and the build itself is a gate: if an assertion fails, nothing is written.

• Tests describe behaviour, not implementation. Otherwise every refactor surfaces as a test failure, and the suite becomes an obstacle instead of a safety net.
• The silent failure is the expensive one. Where the choice is between stopping loudly and degrading quietly, I take the stop — the translation helper throws on a missing string rather than falling back to Hungarian on an English page.

Deployment is not the end of the work; it is where the earlier decisions become visible. If it cannot be rolled back or measured, I do not treat it as finished.

• Security headers and a content security policy, so it is not only the code that limits what may run on the page, but the browser as well.
• A crawler receives finished HTML, not an empty element for JavaScript to fill in later. That makes search visibility a structural question rather than a keyword one.
• Configuration lives in environment variables rather than in code, and secrets never reach the browser.