Skip to content
Marco Macarena
Stylized line-art portrait of Marco Macarena (Marco Aurélio de Araújo Silva)

Hello — I'm Marco Macarena.

  • Senior Software Engineer · Full-Stack, backend-leaning
  • 10+ years building product-oriented systems
  • Python · Django · DRF · React · Docker
  • Product teams · edtech · APIs · internal platforms

Most people shorten the name; the full one is Marco Aurélio de Araújo Silva. I build and maintain web products end to end — often where teaching, product thinking, and backend engineering meet. Based in São Paulo, Brazil. Native Portuguese, fluent English.

Case Studies

Selected work, structured for evaluation. Context, problem, ownership, stack, decisions, outcome.

Press Hook

Senior Full-Stack / Lead Engineer · 2022–2026

Context

AI-driven media relations SaaS product connecting brands with journalists. Small, fast-moving engineering team serving a growing user base of PR professionals.

Problem

The product needed new feature development at speed while the existing codebase required refactoring for performance and maintainability. Both had to happen in parallel without disrupting the user experience.

Ownership

Full ownership across the stack: backend API design and implementation, frontend feature work, deployment pipeline, and performance optimization. Moved into a lead role coordinating technical decisions with the team.

Stack

  • Django
  • Django REST Framework
  • React
  • Docker
  • Google Cloud
  • PostgreSQL

Decisions & trade-offs

Prioritized incremental refactoring over rewrites — improving query patterns and API response times while shipping new features. Containerized the development and deployment workflow to reduce environment drift between staging and production.

Outcome

Sustained feature delivery alongside measurable performance gains. The product remained stable under growth while the codebase became more legible and maintainable for the team.

ImagineAgeTV

Project Manager & Full-Stack Developer · 2013–2021

Context

Production company focused on educational and institutional content. Technology needs spanned internal operations, client-facing platforms, and e-learning delivery across multiple concurrent projects.

Problem

The company relied on manual processes for project and financial management, and lacked integrated tools for e-learning delivery. External platforms needed customization that off-the-shelf solutions could not provide.

Ownership

Dual role: managed projects end to end while building the software. Designed and developed in-house tools, built and maintained Moodle plugins, delivered documented DRF APIs, and managed WordPress-based sites.

Stack

  • Django
  • Django REST Framework
  • Moodle
  • WordPress
  • PHP
  • Python

Decisions & trade-offs

Chose Django + DRF for internal tools to get API-first architecture with solid ORM, even within a small team. Used Moodle for e-learning where institutional adoption was required, building custom plugins rather than fighting the platform. Documented APIs from ORM through endpoint to make future maintenance sustainable.

Outcome

Operational efficiency improved through custom tooling. E-learning delivery scaled across projects with reusable Moodle infrastructure. The API documentation practice enabled handoff and continuity.

Freelance — the recurring pattern

Full-Stack Developer · 2002–present

Context

Two decades of client work across education, small business, and institutional organizations. Projects range from simple web presence to custom web applications and platform deployments.

Recurring problem

Clients with limited technical resources need reliable, maintainable web solutions — often on constrained budgets, with unclear requirements that evolve during delivery.

Ownership

End-to-end: requirements gathering, architecture, development, deployment, and often ongoing maintenance. Single point of contact for technical decisions.

Stack

  • Python
  • Django
  • PHP
  • WordPress
  • Moodle
  • JavaScript

Decisions & trade-offs

Technology choices driven by client context: WordPress where content ownership matters, Django where custom logic is needed, Moodle where institutional e-learning compliance is required. Prioritized solutions the client could maintain after handoff.

Outcome

Long-term client relationships built on trust, shipping under constraint, and clean handoffs. The freelance practice developed the instinct to match tools to real organizational needs, not personal preference.

Experience

Career timeline. Compact, scanable, designed for quick evaluation.

  1. Press Hook

    2022 — 2026

    Senior Full-Stack Engineer / Lead Engineer

    • Django
    • DRF
    • React
    • Docker
    • Google Cloud
    • Built new product features across the full stack for an AI-driven media relations platform
    • Refactored core systems for performance and maintainability
    • Led technical decisions and coordinated engineering work across the team
    • Containerized deployment pipeline on Google Cloud
  2. ImagineAgeTV

    2013 — 2021

    Project Manager & Full-Stack Developer

    • Django
    • DRF
    • Moodle
    • WordPress
    • PHP
    • Developed in-house tools for project management and financial operations
    • Built and maintained Moodle plugins for e-learning delivery
    • Delivered documented DRF APIs from ORM through endpoint
    • Managed e-learning projects end to end alongside development
  3. MadCode / Cel.Lep

    2015 — 2018

    Programming Teacher

    • Taught coding fundamentals and robotics to teens
    • Developed teaching materials and curriculum
  4. Freelance

    2002 — present

    Full-Stack Developer

    • Python
    • Django
    • PHP
    • WordPress
    • Moodle
    • Custom web applications, CMS builds, and e-learning platform deployments
    • Long-term client relationships across education and small business

Education: Pedagogy — University of São Paulo (USP)

How I think about building software

The conceptual layer — what I believe, grounded in what I do.

Software is a translation between human intent and structured systems.

I design APIs and internal tools that reduce ambiguity between product, engineering, and operations — making the system legible to every stakeholder, not just the people who write code.

Clarity is a feature, not a side effect.

I document APIs from ORM through endpoint, write code that reads well six months later, and structure pull requests so reviewers can follow the reasoning — not just the diff.

Teaching changes how you build.

A background in Pedagogy (USP) informs how I design systems, write documentation, and onboard teammates. I design for the person who will maintain it after me — the way a good teacher designs for the learner, not the curriculum.

Refactoring is delivery, not avoidance.

At Press Hook, I refactored core systems in parallel with feature work — improving query patterns and response times without freezing the product. Incremental improvement compounds.

Choose tools by context, not preference.

WordPress where content ownership matters. Django where custom logic is needed. Moodle where institutional compliance requires it. The right tool is the one the team and the client can sustain.

Small teams ship differently — and that's a skill.

Two decades of freelance and small-team work built the instinct to scope tightly, communicate directly, and make technical decisions that account for limited resources. Constraint is not a limitation — it's a design parameter.

Stack

Organized by depth. Not everything I've used — what I'm strong in and how confident I am.

Core

Daily practice. Deep expertise. Where I'm most effective.

  • Python
  • Django
  • Django REST Framework

Strong

Production experience. Comfortable leading work in these.

  • React
  • JavaScript
  • SQL
  • Docker
  • Git

Working knowledge

Contextual use. Can deliver, choose wisely, and maintain.

  • Vue.js
  • PHP
  • WordPress
  • Moodle
  • Google Cloud
  • HTML / CSS

Also part of the practice

  • APIs
  • Internal tools
  • Product systems
  • Documentation
  • Developer experience
  • E-learning platforms

Writing & communication

Clear technical communication is part of the engineering value, not a soft extra.

API documentation

End-to-end documentation of Django REST Framework APIs — from ORM design through serializers to endpoint reference. Written for the developer who inherits the project, not just the one building it.

System explanation

Technical writing that bridges engineering decisions and stakeholder understanding. Architecture notes, decision records, and onboarding materials designed for mixed audiences.

Code as communication

Pull requests structured for reviewability. Commit messages that explain intent, not just action. Code organized so the next reader follows the logic without needing a walkthrough.

Teaching-informed design

A pedagogy background applied to developer experience: error messages that guide, interfaces that teach, documentation that meets people where they are.

Let's talk

Available for senior full-stack or backend-leaning roles in product teams. Open to contract work and edtech collaborations. Remote or hybrid in São Paulo.