Professional work

Natasha Skin Care

A beauty and skincare platform spanning customer, doctor, commerce, and operational workflows.

Role
Software Engineer - Backend and Distributed Systems
Status
Active

What this project shows

Context

Client work across web, mobile, commerce, and internal platform systems.

My contribution

Built CMS and backend services for customer, doctor, recipient, schedule, and operational workflows.

Why it matters

Production experience building shared backend services for a multi-surface platform.

Public evidence

Highlights

  • Shared backend services across customer and doctor workflows
  • CMS and operational management systems
  • Customer and doctor mobile applications
  • Commerce and loyalty workflows
  • Multi-surface platform architecture

Backend Engineering - Distributed Systems - CMS - Mobile & Commerce Platform

Overview

Natasha Skin Care is a beauty and skincare platform with digital experiences spanning customer engagement, doctor workflows, product discovery, commerce, loyalty, and internal operations.

Public project materials describe a broader product ecosystem that includes:

  • a website and product showcase;
  • a Natasha Customer App;
  • a Natasha Doctor App;
  • mobile applications for iOS and Android;
  • an e-commerce loyalty platform;
  • supporting end-to-end operational systems.

As part of the Technopartner Indonesia engineering team (my current role, since September 2024), I contribute to the backend systems supporting these product surfaces, with a focus on backend services, distributed systems, service-oriented architecture, and shared operational workflows.

My work centers on the layer that connects internal management capabilities with customer-facing, doctor-facing, and commerce-facing applications.


Engineering Challenge

A platform with multiple application surfaces introduces a different engineering problem from a single standalone application.

Customers, doctors, operators, and commerce workflows interact with different parts of the product, but many of those interactions depend on the same underlying business concepts.

Examples include:

  • customers;
  • doctors;
  • recipients;
  • schedules;
  • products;
  • transactions;
  • service interactions;
  • operational records.

The challenge is not only to expose APIs for each application.

The backend needs to preserve consistent domain behavior while allowing multiple product surfaces to evolve independently.

From an engineering perspective, this creates several important concerns:

  • defining clear service responsibilities;
  • preventing duplicated business logic across applications;
  • maintaining consistent domain data;
  • coordinating workflows that cross service boundaries;
  • supporting different read and write patterns across customer and doctor applications;
  • integrating internal CMS workflows with public product surfaces;
  • managing failure and partial availability in distributed workflows;
  • scaling services independently as traffic and product requirements change;
  • maintaining backward compatibility as applications evolve at different speeds.

The result is a backend platform problem rather than a collection of isolated endpoints.


My Role & Contribution

I contributed to the backend and operational platform foundation supporting Natasha’s digital product ecosystem.

My work included the CMS management layer and backend services around several operational domains, including:

  • doctors;
  • recipients;
  • customers;
  • schedules;
  • supporting operational workflows;
  • integrations between internal management and application-facing services.

The objective was to provide reliable backend capabilities that could be reused across multiple product surfaces while keeping domain behavior consistent.


CMS & Operational Management

One of my main areas of contribution was the overall CMS and internal management system.

The CMS acts as an operational interface over several backend domains rather than existing as an isolated administrative application.

At a high level:

The operations team works through the CMS, which reaches backend services and the doctor, customer, schedule, recipient, and other operational domains.

Mermaid preview

This management layer allows internal workflows to interact with the same underlying service capabilities used by other application surfaces.

That helps reduce duplicated business rules between administrative and customer-facing systems.


Multi-Surface Platform Context

The platform supports multiple product surfaces with different responsibilities.

The web platform, customer app, doctor app and commerce and loyalty surfaces all call one backend platform that owns the shared domain services.

Mermaid preview

Each surface serves a different product need, but shared backend services provide common domain behavior.

This architecture avoids treating each application as an entirely independent system.


Backend Service Architecture

At a conceptual level, the backend can be viewed as a collection of domain-oriented services behind shared application surfaces.

Application clients call a backend layer exposing customer, doctor, schedule, recipient, commerce, and operational services, all resting on shared data and infrastructure.

Mermaid preview

The purpose of this separation is not simply organizational.

Clear domain boundaries help reduce coupling between unrelated workflows and make it easier for individual parts of the platform to evolve independently.


Customer Workflows

Customer-facing applications need access to a combination of profile, product, commerce, service, and engagement capabilities.

Conceptually:

The customer app reaches backend APIs that cover customer data, product discovery, commerce, loyalty, and service workflows.

Mermaid preview

The backend acts as the shared coordination layer between these capabilities.

A change in customer information, for example, may need to remain consistent across more than one downstream workflow.


Doctor Workflows

Doctor-facing applications operate over a different set of responsibilities while still sharing some platform domains.

The doctor app reaches backend APIs that cover the doctor domain, customer information, schedule management and operational workflows.

Mermaid preview

This introduces shared-data challenges because customer-related information may be consumed by both customer-facing and doctor-facing applications.

The backend therefore needs clear rules around ownership and consistency rather than allowing each client application to implement its own interpretation of the domain.


Schedule & Operational Workflows

Scheduling is a good example of a workflow that can cross multiple product surfaces.

Customers, doctors, and the CMS all reach the same schedule service, whose state feeds downstream workflows.

Mermaid preview

Different users may interact with the same underlying schedule state through different interfaces.

The service layer becomes responsible for keeping these interactions coherent.


Shared Domain Model

A major system-design concern in multi-surface platforms is maintaining consistent ownership of shared concepts.

Customer, doctor, schedule, recipient, product, and transaction are related domain concepts that several surfaces read and write.

Mermaid preview

These relationships create dependencies between otherwise separate workflows.

A backend service architecture needs to make those dependencies explicit enough to preserve consistency without turning every service into a tightly coupled component.


Distributed System Context

As the platform grows, backend interactions naturally become distributed across multiple services and operational boundaries.

A client application calls a service that depends on further services, a data layer and an external or shared capability.

Mermaid preview

This introduces concerns that are less visible in a single-process application:

  • network failures;
  • service timeouts;
  • partial availability;
  • duplicated requests;
  • inconsistent state;
  • dependency latency;
  • cascading failures;
  • version compatibility.

Backend design therefore needs to account for failure as a normal system condition rather than assuming every dependency is always available.


Service Boundaries

A useful service boundary should reflect business responsibility rather than simply splitting code into smaller deployments.

Conceptually:

The platform is divided into customer, doctor, scheduling, commerce, and operational domains.

Mermaid preview

Each domain can evolve around its own responsibilities while exposing controlled interfaces to the rest of the platform.

This helps avoid a distributed monolith where services are technically separate but still tightly dependent on one another internally.


Data Consistency

Multi-surface systems often involve the same logical entity appearing across several workflows.

For example:

A single customer record is read and written by the customer app, doctor workflows, commerce, and the CMS.

Mermaid preview

The engineering challenge is determining where authoritative state lives and how other parts of the system consume or update it.

Without clear ownership, multiple applications can begin maintaining slightly different versions of the same business concept.

That creates correctness problems that become progressively harder to resolve as the platform grows.


Request Flow

A simplified application request may cross several backend responsibilities before reaching a final result.

A client request reaches the API, which asks a domain service to execute a workflow, resolving a supporting dependency and reading or updating state before the response returns.

Mermaid preview

This type of workflow requires clear responsibility for validation, orchestration, domain logic, persistence, and failure handling.


Engineering Principles

Shared Behavior Belongs in the Backend

When several clients operate on the same business concepts, critical rules should not be independently implemented by every application.

The customer app, doctor app, CMS and web all resolve to the same shared backend rules.

Mermaid preview

Centralizing domain behavior in backend services reduces the chance that different product surfaces implement conflicting rules.


Service Boundaries Should Follow Domains

Splitting a system into microservices only improves architecture when service boundaries have meaningful responsibilities.

Useful boundaries generally correspond to ownership of business capabilities rather than arbitrary technical layers.

A domain responsibility becomes a service boundary, then an API contract, which is what allows independent evolution.

Mermaid preview

The goal is controlled coupling, not maximum service count.


Consistency Over Duplication

A multi-surface platform can become difficult to maintain if every client develops its own interpretation of shared concepts.

The backend therefore acts as the consistency layer between product experiences.

Multiple product surfaces rely on shared domain services to produce consistent business behaviour.

Mermaid preview


Distributed Systems Fail Partially

A distributed system rarely fails as a single binary unit.

One dependency may be unavailable while other parts of the platform continue operating.

An application request reaches a service that depends on several other services, which is where partial failure becomes possible.

Mermaid preview

This makes timeout handling, graceful failure, retries, idempotency, observability, and dependency isolation important engineering concerns.


Independent Evolution Matters

Customer applications, doctor applications, internal tools, and commerce systems rarely evolve at the same pace.

Backend interfaces therefore need enough stability to allow one product surface to change without forcing synchronized releases across the entire platform.

Backend contracts are consumed by the customer app, doctor app, CMS, web and commerce surfaces.

Mermaid preview

Stable contracts reduce coupling between product teams and release cycles.


System Evolution

As new workflows are introduced, the platform can grow by extending existing domains or introducing new service responsibilities.

A new business capability either extends an existing service when its domain exists or defines a new service boundary when it does not.

Mermaid preview

This approach is preferable to adding every new feature into a single shared service.

The objective is to keep system complexity proportional to business complexity.


Public Product Context

According to Technopartner’s public portfolio material, the Natasha project includes the Natasha Customer App and Natasha Doctor App.

The public description presents the customer-facing solution as including:

  • website and product showcase;
  • mobile applications for iOS and Android;
  • e-commerce capabilities;
  • loyalty-oriented workflows.

The doctor-facing solution is presented as a mobile application for iOS and Android within a broader end-to-end platform.

Public References

Scope, Limits & Confidentiality

Natasha is a proprietary commercial product.

This case study intentionally describes my contribution at the engineering-domain and system-design level rather than exposing private implementation details.

The following are intentionally omitted:

  • proprietary source code;
  • internal architecture diagrams;
  • infrastructure topology;
  • customer data;
  • production credentials;
  • private API specifications;
  • internal database schemas;
  • proprietary business rules;
  • deployment configuration;
  • internal operational data;
  • confidential team responsibilities.

The architecture diagrams shown here are conceptual representations intended to explain the engineering problems involved.

They are not reproductions of Natasha’s private production architecture.

Public product descriptions are based on publicly available material, while descriptions of my contribution remain intentionally high-level.


Why This Work Matters

Multi-surface products create backend complexity that is easy to underestimate.

A customer app, doctor app, CMS, website, and commerce system may appear to be separate products, but they often depend on the same underlying domain concepts and operational workflows.

The engineering difficulty therefore lies in making those surfaces behave as one coherent platform.

That requires:

  • clear domain ownership;
  • reusable backend capabilities;
  • stable service contracts;
  • consistent business rules;
  • controlled service dependencies;
  • resilient distributed workflows;
  • maintainable operational systems.

This work sits at the intersection of:

backend engineering, distributed systems, domain modeling, service architecture, API design, commerce systems, internal tooling, and platform engineering.

My contribution to Natasha focuses on that intersection: building and connecting backend services that allow multiple product surfaces to share consistent business behavior while remaining maintainable as the platform evolves.

Search this site