My technical repertoire and how I choose each product stack

Before choosing any tool, I consider the product stage, domain, team experience, budget, security requirements, expected volume, and who will maintain the system.

I prefer a clear and well documented foundation. A new technology enters when it genuinely improves delivery, operations, or experience, not simply because it is popular.

I work across backend ecosystems to build APIs, transactional services, integrations, operational panels, and SaaS products. Node.js and NestJS are common choices, while Ruby on Rails, Python, Java, .NET, and PHP remain important when their ecosystems fit the context.

I also define REST, GraphQL, or gRPC contracts, authentication, authorization, queues, asynchronous jobs, and boundaries between modules. Language is one part of the solution; domain clarity and reliable operations matter just as much.

For web products, I use Next.js, React, and TypeScript to build responsive interfaces, API integrations, and journeys that remain understandable as the product grows. Rendering, state, and forms are selected according to the expected experience, SEO, and application profile.

The foundation includes accessibility, validation, performance, reusable components, and journey testing. The goal is not merely to assemble screens, but to create a product that can be understood, maintained, and used safely.

I use relational databases when consistency and structured queries are central, and specialized components when caching, documents, search, or analytics require another format. Modeling, indexes, migrations, retention, and recovery are part of the decision.

For analysis, I work with SQL, Power BI, and models that turn operational data into understandable indicators. Value appears when the company can answer questions and make decisions, not when it merely accumulates information.

I choose architecture according to the domain, risk, and team capacity. A well defined modular monolith is often a better foundation than distributed services introduced too early; microservices enter when boundaries, scale, and operational autonomy truly justify the separation.

Patterns help organize decisions, but they do not replace understanding. Clean Architecture, DDD, hexagonal architecture, events, and CQRS are applied when they reduce coupling and make responsibilities more explicit.

I take care of the foundation that brings software into production and keeps it observable. This includes Linux servers, containers, networking, proxies, certificates, pipelines, artifact registries, monitoring, logs, backups, and controls proportional to service criticality.

I work with public cloud and VPS environments according to cost, availability, and control needs. Harness in this area means the CI/CD platform; it is different from Harness Engineering, which belongs to the working method.

I also develop interactive experiences for browsers, communities, and gaming platforms. This work combines gameplay logic, interfaces, session synchronization, assets, performance, and integration with external services.

Phaser and Three.js serve web experiences; Unity, Unreal Engine, and Godot cover products that need complete engines. The Discord Activities SDK enables social experiences that run inside a server context, including games and shared sessions.

Not every problem requires a system built from scratch. Often the best result comes from configuring a mature platform, integrating data, and adapting the flow to the way the company operates.

I work with customer service, CRM, ERP, payments, WhatsApp, and operational automation. Implementation includes credentials, webhooks, queues, access rules, audit trails, and a maintenance routine, not only the initial connection.

For internal automation, I build harnessed agents: a controlled layer around the model that defines context, memory, allowed tools, permissions, execution limits, evaluations, logs, checkpoints, and moments for human approval.

These agents can consult internal systems, classify requests, prepare responses, generate reports, update a CRM or ERP, and trigger workflows. They do not receive unrestricted access; each capability is exposed as an auditable tool with defined scope and responsibility.

When the process is predictable, I use a deterministic workflow, often with n8n. An agent enters when interpretation and flexibility create enough value. RAG, MCP, and tool catalogs help connect knowledge and actions without hiding data provenance.

Specifications, decision records, tests, code review, documentation, and observability determine how safely a team can evolve. That is why method is also part of my technical repertoire.

I use SDD to turn intent into verifiable criteria, Context Engineering to organize what people and agents need to know, Loop Engineering to shorten implementation and evaluation cycles, and Harness Engineering to create reliable limits, tools, and feedback around AI assisted execution.

I map what already exists before proposing replacements. Often the highest value path is to stabilize the current foundation, improve visibility, document decisions, and solve priority integrations.

When a product starts from zero, I choose a foundation that is simple enough for the moment and prepared to grow with evidence. The stack should increase company autonomy, bring technology closer to the business, and allow other people to continue the work.