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:
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
Backend Service Architecture
At a conceptual level, the backend can be viewed as a collection of domain-oriented services behind shared application surfaces.
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 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.
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
Shared Domain Model
A major system-design concern in multi-surface platforms is maintaining consistent ownership of shared concepts.
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.
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:
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:
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
Engineering Principles
Shared Behavior Belongs in the Backend
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.
The goal is controlled coupling, not maximum service count.
Consistency Over Duplication
Distributed Systems Fail Partially
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.
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.
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.