I work across the software development lifecycle, from understanding requirements and planning architecture to implementation, deployment, optimization, and maintenance.

My primary focus is backend and systems engineering, supported by full-stack development, database design, infrastructure, automation, and practical AI-assisted workflows. I value software that is understandable, maintainable, observable, and designed around real requirements rather than unnecessary complexity.

const engineer = {
  name: "Marquis Evander",
  location: "Indonesia",
  focus: [
    "Software & Project Engineering",
    "Backend Systems & API Design",
    "Data Architecture",
    "Full-stack Application Development",
    "Infrastructure & Automation",
    "AI-assisted Development & Maintenance",
  ],
  principle: "Build for clarity, reliability, and long-term maintainability.",
};

Turning requirements into maintainable software through structured planning and implementation.

• Requirement analysis and technical decomposition
• Project structure, module boundaries, and dependency planning
• API contracts and integration design
• Technical documentation, issue planning, and implementation workflows
• Code review, testing, refactoring, and maintenance
• Performance, reliability, and operational considerations

Designing data layers around application requirements, consistency, and query patterns.

• Relational data modeling, entities, relationships, and constraints
• PostgreSQL and MySQL schema design
• Query design, indexing, transactions, and data integrity
• Redis caching and key-expiration strategies
• Data access layers and repository patterns where appropriate
• Schema evolution, migration planning, and ORM trade-offs

• REST API design, validation, authentication, and authorization
• Service and module architecture
• Background jobs, automation, and asynchronous workflows
• Caching, integrations, and performance optimization
• Linux server operations, reverse proxies, and deployment workflows
• Security-conscious implementation and debugging

• Responsive web interfaces with React and Next.js
• TypeScript and JavaScript application development
• UI integration with backend APIs
• Interactive 3D experiences and browser-based visualization with Three.js
• Maintainable component structures and practical responsive behavior

I use AI coding tools as part of an engineering workflow, not as a replacement for engineering judgment. This includes using AI to accelerate implementation, understand unfamiliar code, explore solutions, and support ongoing maintenance.

• Prompting and task decomposition from requirements into actionable issues
• AI-assisted implementation, refactoring, and codebase exploration
• Debugging support, test generation, and documentation
• Maintenance assistance for existing systems and legacy code
• Reviewing generated changes for correctness, security, performance, and consistency
• Validating outcomes through tests, inspection, and runtime behavior

The goal is faster iteration without surrendering code quality, architectural control, or responsibility for the result.

The technologies below represent tools I work with or explore across different projects. Their use depends on project requirements and trade-offs.

• GORM — Go ORM for mapping structs to database records and working with CRUD operations, associations, transactions, and schema migration workflows.
• ORM concepts — object-relational mapping, entity relationships, query construction, data access abstraction, and the trade-offs between ORM convenience and direct SQL control.
• Data practices — schema design, indexing, query analysis, transaction boundaries, and data integrity.

An ORM does not replace database knowledge. I consider the generated SQL, query performance, transaction behavior, and migration impact when choosing how to access data.

Project Engineering
├── Requirement analysis & technical planning
├── Issue decomposition & implementation workflow
├── API contracts & system integration
└── Testing, review, refactoring & maintenance

Backend Engineering
├── REST APIs & service design
├── Authentication & authorization
├── Background jobs & automation
└── Caching & performance optimization

Data Architecture
├── Relational modeling & schema design
├── PostgreSQL / MySQL / MongoDB
├── ORM & data access patterns (GORM)
├── SQL, indexing & transactions
└── Redis caching & data integrity

Application Engineering
├── React / Next.js / TypeScript
├── Responsive user interfaces
├── Three.js & interactive 3D
└── API-driven full-stack applications

AI-assisted Engineering
├── Requirements-to-issue workflows
├── AI-assisted coding & codebase exploration
├── Debugging, tests & documentation
└── Human review, validation & maintenance

Infrastructure & Security
├── Linux & Nginx
├── Deployment & operational workflows
├── Web / API security fundamentals
└── Automation & system troubleshooting

1. Understand the requirements before choosing the implementation.
2. Keep architecture understandable and proportionate to the problem.
3. Treat data modeling and database behavior as core architectural concerns.
4. Use abstractions when they improve maintainability, not by default.
5. Measure performance before optimizing.
6. Design APIs with explicit contracts and predictable errors.
7. Use AI to accelerate work while validating every consequential change.
8. Include testing, security, documentation, and maintenance in the development lifecycle.

Requirements
    ↓
Technical analysis & project decomposition
    ↓
Architecture, data model & API contracts
    ↓
Implementation (manual + AI-assisted where useful)
    ↓
Testing, review & validation
    ↓
Deployment, monitoring & maintenance