Backend Engineer - AWS & APIs-Frontend Integration awareness -México Only

Role Summary

We are looking for a hands-on Backend Engineer responsible for designing, building and operating backend services in production within a corporate AWS environment. The core of the role is solid backend development: well-structured APIs, applied design patterns, secure and auditable code.

The candidate will not be responsible for frontend development, but must ensure that the services they build are correctly designed to be consumed by applications in React/Next: clear response structures, validations, integration contracts and error handling.

The company operates under strict corporate guidelines: headquarters audits the code, there are automatic quality and safety verification tools before each promotion between environments. The candidate is expected to arrive with good practices already internalized, not as something to be learned on the job.

We are looking for someone who

Has had direct responsibility for what he builds

You can clearly explain what you developed, how it works, and why it was designed this way.

• Has worked in real contexts (production, incidents, pressure, ambiguity)
• You can make decisions and move forward without constantly depending on others
• Communicates in a clear, direct and structured way

It is important that the candidate

• Have worked with AWS in production (not just theory)
• Understand how services are deployed and code promoted between environments
• Understand how your code impacts security, deployment and operation
• Services with which practical experience is expected

Lambda: creation, configuration of triggers, connection with other services, management of timeouts and errors.

API Gateway: creation of APIs, integration with Lambda, management of stages and authorizers.

S3: object management, permissions, access policies, lifecycle rules.

DynamoDB or RDS: CRUD operations, indexes, connection from backend services.

IAM: roles, policies, principle of least privilege — know why it matters and how to apply it.

Infrastructure as Code (IaC) — required functional knowledge

Understand what it is and what it is for: no resources are created manually in the console.

You can read and understand a CloudFormation template or CDK/Terraform module even if it's not your specialty.

Know how to declare a Lambda, API Gateway, or IAM role in code.

Understand the cycle: write IaC → plan/preview → controlled deploy.

• Cloud security — expected level
• Understand basic good security practices when working in AWS
• You know that access between services should be handled using roles (not hardcoded credentials)
• Have an understanding of how exposed APIs are protected
• Learn basic practices for secure handling of secrets

Specialization in cloud security is not required, but sufficient criteria is required to develop without compromising the environment.

Third front: — REACT / NEXT.JS —

The candidate will not develop frontend. But it will build the backend that powers it. You must understand enough to ensure that your services work correctly in integration.

-How the frontend consumes an API- You understand what response structure it expects, what headers you need, how to handle HTTP errors

-fetch / axios or equivalent: You know how to make a call from the frontend — you can design your API with the caller in mind.

-Basic state management: You understand what data the frontend saves and when it needs to refresh it from the backend.

-What is a hook (conceptual level): Do you know that the frontend handles asynchronous effects

-Form validation: You understand what the frontend validates vs what the backend should validate (and why the backend should always validate).

-Protection of endpoints consumed by frontend: You know how to implement authentication/authorization thinking about a React client.

Responsibilities

We hope to identify in you

• Ease of talking about your APIs with product ownership: you know the input, the output, the error cases, who consumes it and why it was designed that way.
• Clarity to explain step by step how you built or modified a real service: from the definition of the endpoint to its deployment in production.
• Agility when presented with a technical scenario: giving a concrete solution without evading or diverting the case.
• Ability to recognize trade-offs: knowing when to use a Lambda vs a container, a relational database vs a NoSQL, and being able to justify it.
• Transparency to share when you have had incidents in production and be able to describe how you identified, attended to and prevented them.

Good practices — 'CLEAN CODE'

• This point is critical. The code is automatically evaluated in each promotion between environments, so it is important to have well-consolidated good practices from the beginning.
• Design patterns — you must know and know how to apply at least one
• Clean Architecture (also called Clean Architecture): separation of layers, dependencies pointing inward, domain independent of infrastructure.
• Layered Architecture (Layered / N-tier): presentation, business, data — clearly separated.
• Onion Architecture: core domain surrounded by concentric layers of adapters.
• Clean code — what we hope to see in the way you work
• You will be expected to be able to explain how you structure your code, how you separate responsibilities, and how you handle errors in real services, with clear examples of what you have built.
• Clear separation of responsibilities: Each class, function or module serves a specific purpose.
• Use descriptive names that make the code easy to understand without the need for additional explanations.
• Business logic located in the correct layers (services or domain), not in controllers.
• Clean and maintainable code, avoiding redundancies or unnecessary elements.
• Explicit error handling, with adequate control and traceability.

Security in code — required, not optional

• Validation of inputs in backend (do not trust the frontend to validate).
• Endpoint protection: Authentication + authorization properly implemented.
• Do not hardcode credentials, API keys or secrets in the code — use environment variables or services such as AWS Secrets Manager.
• Basic knowledge of OWASP Top 10: SQL injection, XSS, broken auth, etc.
• Logging without exposing sensitive data (PII, tokens, passwords).
• Second Front: — CLOUD AWS —
• AWS is a key component of the role.
• Real production experience and understanding of how the backend lives within a cloud environment is expected, but the main focus is still backend.
• Ability to explain how you have deployed services, how they connect to each other, and how your code impacts the environment is expected.

Requirements

• Professional profile and soft skills —
• In interview, we hope to see
• Concrete explanations, not theoretical
• Structured way of thinking

Ability to propose real solutions

• Technical profile — SKILLS MAP
• Essential (without this you will not advance)
• Hands-on backend in production
• REST APIs + security
• AWS applied in production
• Design patterns

Clean and maintainable code

• IaC: functional knowledge (understand how it works and how it impacts deployment)
• Flexible (can compensate with clear potential)
• React / Next (integration level, not deep development)
• IaC: direct development (writing from scratch)

AWS Advanced Services

Experience in highly regulated environments

Nice to have

• AWS Certification
• Experience in the financial sector
• Experience in audited corporate environments
• Knowledge of CI/CD (not full ownership)
• First Front: — BACKEND —

You are not required to have designed entire enterprise architectures, but you are required to be able to autonomously build components, make informed technical decisions, and understand the impact of your code on the entire system. You are not looking for an architect who delegates, you are looking for someone who executes with criteria.

• (real hands-on)
• Experience developing APIs in production (Node, Python, C#, Java)
• Design of REST APIs (endpoints, validations, error handling)
• Authentication/authorization implementation (JWT, OAuth2 or similar)
• Database management (SQL and/or NoSQL)
• Actual experience executing (not just designing or leading)
• Backend stack
• C# (.Net) or Node.js or Python as the main language. It doesn't matter which one, what matters is the depth.
• Development of REST APIs: resource design, versioning, authentication (JWT, OAuth2), role authorization.
• Management of relational databases (SQL) and ideally some NoSQL. Optimized queries, transactions, indexes.
• Robust error handling: consistent responses, structured logging, traceability.
• Unit and integration tests: not only knowing that they exist, but also knowing how to write and maintain them.

Benefits

• 🚀 Integration to global brands and disruptive startups.
• 🏡 Remote work/Home office.
• 📍 If you require hybrid or in-person modality, you will be informed from the first session.
• ⏳ Schedule adjusted to the assigned work cell/project.
• 📅 I work from Monday to Friday.
• 🎉 Day off on your birthday.
• 🏥 Major medical expense insurance (applies to Mexico).
• 🛡️ Life insurance (applies to Mexico).
• 🌎 Multicultural work teams.
• 🎓 Access to courses and certifications.
• 📢 Meetups with special guests from the IT area.
• 📡 Virtual integration events and interest groups.
• 📢 English classes.
• 🏆 Opportunities within our different lines of business.
• 🏅 Proudly certified as a Great Place to Work.