Open to new opportunities

End-to-End Android & Backend Engineering

terminal://jlsh-portfolio/hero

Type help

About me

José Luis Salado Horta

I am a Software Developer focused on building end-to-end products with a methodical approach. I prioritize the 'why' over the 'how', ensuring every component has an explicit purpose. In the age of AI, I believe our true value lies in system design and infrastructure—mastering not just how to generate code, but how to make it resilient, scalable, and reliable in production.

Interactive shell

Welcome to jlsh-portfolio v1.0.0 — Type `help` to list available commands.

jlsh@jlsh-portfolio:~$

Press Enter to run commands. Try help, projects, or demo.

View Projects

Download CV

GitHub

Technologies

Android

Modern Android architecture and product-focused app development.

Architecture

Clean ArchitectureMVVMDependency Injection

UI & State

Jetpack ComposeMaterial 3Coroutines/Flow

Data & Networking

RoomRetrofit + OkHttpHiltCoilFirebase

Backend

Robust services with explicit contracts and maintainable design.

Frameworks & APIs

Spring BootFastAPIREST APIsspringdoc-openapi

Architecture

Hexagonal ArchitectureDependency InjectionSpring Security + JWTMapStruct

Persistence

PostgreSQLMySQLSpring Data JPASQLAlchemyFlyway

AI Integration

Google Gemini

Tools

Tooling for reliable delivery, quality, and team velocity.

Infrastructure & Dev Environment

DockerDocker ComposeGitGitHub

Testing & Quality

JUnitMockitoPytestTestcontainersJaCoCo

Developer Productivity

IntelliJ IDEAAndroid StudioSwagger/OpenAPIAI-Assisted Development (Cursor, Claude, ChatGPT, Gemini, GitHub Copilot)SonarQube

Projects

Featured ProjectCompleted

AlFit

Final Degree Project · AI-powered fitness and nutrition platform

Sole developer — Android client & backend API (TFG)

A distributed product: Kotlin Android client and Spring Boot API sharing explicit contracts, offline-first UX, and Gemini behind hexagonal ports.

KotlinJava 21Spring BootComposePostgreSQLGemini

GitHub Android GitHub Backend

Users need structured training and nutrition that adapts to real progress—not static plans—without relying on an in-person coach.

0115 feature modules on Android with Clean Architecture and offline-first Room.

02Versioned REST API with hexagonal domain, Flyway, and Testcontainers-backed CI.

03Seven Gemini adapters isolated behind ports for plans, coach, vision, and education.

Product screens

Selected flows from AlFit (Android client).

Use cases

≥80%

JaCoCo gate

V1–V37

Flyway

AI adapters

System overview

Architecture

Android Client

Application Layer

Clean Architecture · MVVM · StateFlow

KotlinJetpack ComposeHiltRoomRetrofit

Feature modules with isolated use cases and testable domain rules.
Room as single source of truth; Retrofit syncs asynchronously.
UiState / UiEvent pattern for predictable Compose screens.

Spring Boot Backend

Service Layer

Hexagonal Architecture · Ports & Adapters

Java 21Spring Boot 3PostgreSQL 16FlywayTestcontainers

Domain isolated from Spring Web, JPA, and Gemini infrastructure.
Flyway migrations validated in CI against real PostgreSQL.
springdoc-openapi and JWT security for production-ready API surface.

Technical decisions

Why hexagonal architecture?

The domain stays isolated from Spring DI and JPA. Swapping the Gemini adapter for another provider requires zero changes to core fitness logic.

// ports & adapters

Why Testcontainers?

In-memory databases lie about production behavior. Each suite runs against PostgreSQL 16 with real migrations; JaCoCo at 80% is a hard CI gate.

// integration > mocks alone

Why Room + Retrofit?

ViewModels observe Room Flow—they never care if data came from network or cache. The app stays usable when connectivity drops mid-workout.

// offline-first

Android · Retrofit

interface WorkoutApiService {
  @GET("api/v1/workouts/plan")
  suspend fun getWorkoutPlan(
    @Header("Authorization") token: String,
    @Query("goal") goal: String,
  ): Response<WorkoutPlanDto>
}

Backend · Spring Controller

@RestController
@RequestMapping("/api/v1/workouts")
public class WorkoutController {
  @GetMapping("/plan")
  public ResponseEntity<WorkoutPlanDto> getWorkoutPlan(
      @RequestHeader("Authorization") String token,
      @RequestParam String goal) {
    return ResponseEntity.ok(service.getWorkoutPlan(goal));
  }
}

Google Gemini behind ports

AI logic lives in infrastructure adapters. The domain calls ports like AiGeneratorPort without knowing the provider; prompts stay in dedicated builders.

GeminiGeneratorAdapterAiGeneratorPort
GeminiCoachAdapterAiCoachPort
GeminiFoodVisionAdapterFoodVisionPort
GeminiNutritionAnalysisAdapterNutritionAnalysisPort
GeminiEducationAdapterEducationAiPort
GeminiShoppingListAdapterShoppingListAiPort
GeminiSubstitutionAdapterSubstitutionAiPort

Domain port

public interface AiGeneratorPort {
  WorkoutPlan generateWorkoutPlan(UserProfile profile);
  NutritionPlan generateNutritionPlan(UserProfile profile);
}

Live demo

Try the Android client on Appetize — the demo opens in a new browser tab.

Launch live demo

See how I approach design decisions

Experience

Professional timeline

Feb 2026 - May 2026

Backend Developer

Libnamic

Latest

Structured FastAPI services by layers so business rules stay isolated from HTTP and persistence.
Added integration tests with real PostgreSQL coverage to catch regressions before release.
Delivered Dockerized environments that cut local onboarding to a single compose up.

FastAPIPostgreSQLDockerPytest

Feb 2025 - May 2025

Software Developer (Android)

IDITIC Software

Refactored payment screens and reduced technical debt in legacy modules.
Optimized Compose recomposition to improve interaction smoothness on client devices.
Coordinated fixes with product stakeholders to close production incidents.

KotlinJetpack ComposeRoomCoroutines

How I make design decisions

I do not pick patterns for their own sake—I match structure to constraints: connectivity, security, release cadence, and who owns which layer. Each scenario below is a principle I reuse across projects, with a concrete walkthrough from AlFit, my Android + Spring Boot TFG.

Example · AlFit

architecture

Prioritize continuity when the network is unreliable

Problem

Mobile users move through dead zones; blocking the UI on every request creates churn. I default to showing something useful immediately, then reconciling with the server when connectivity returns.

Decision

Separate what must be online from what can be cached. Use a cache-first repository: emit loading, serve local data, refresh remotely, and persist by user scope. Reserve live calls for actions that truly need authoritative state.

Trade-off

More data-layer work (DAOs, mappers, sync rules) in exchange for predictable UX and a domain layer that does not depend on a specific network stack.

Technical flow

01Principle: UI → ViewModel → UseCase → Repository abstraction.
02AlFit: TrainingRepositoryImpl — Flow with Loading → Room → Retrofit.
03AlFit: DTO → domain mapper; upsert in AiFitDatabase by userId.
04AlFit: Spring controller → UseCaseImpl → JPA → PostgreSQL.

15 on Android

AlFit feature modules

data · domain · ui

Layers per feature

Room + DataStore

Local persistence

Outcome

The product stays usable in poor conditions; when the network is back, local state converges with the backend without rewriting screens.

Contact

Open to Android and backend roles where architecture, ownership, and product impact matter.

Best channel

joseluisalado@gmail.com

Email for direct opportunities and technical chats.

Location

Spain

Open to remote and international teams.

Availability

Actively open to new roles

Typical response time: under 24 hours.

To get the best reply

Share role scope, team context, and expected responsibilities.
Mention stack and architecture constraints (Android, backend, infra).
Include timeline and interview process if available.

Get in touch

Send email Connect on LinkedIn View GitHub Download CV

Featured ProjectCompleted

AlFit

Final Degree Project · AI-powered fitness and nutrition platform

Sole developer — Android client & backend API (TFG)

A distributed product: Kotlin Android client and Spring Boot API sharing explicit contracts, offline-first UX, and Gemini behind hexagonal ports.

KotlinJava 21Spring BootComposePostgreSQLGemini

GitHub Android GitHub Backend

Users need structured training and nutrition that adapts to real progress—not static plans—without relying on an in-person coach.

0115 feature modules on Android with Clean Architecture and offline-first Room.

02Versioned REST API with hexagonal domain, Flyway, and Testcontainers-backed CI.

03Seven Gemini adapters isolated behind ports for plans, coach, vision, and education.

Product screens

Selected flows from AlFit (Android client).

Use cases

≥80%

JaCoCo gate

V1–V37

Flyway

AI adapters

System overview

Architecture

Android Client

Application Layer

Clean Architecture · MVVM · StateFlow

KotlinJetpack ComposeHiltRoomRetrofit

Feature modules with isolated use cases and testable domain rules.
Room as single source of truth; Retrofit syncs asynchronously.
UiState / UiEvent pattern for predictable Compose screens.

Spring Boot Backend

Service Layer

Hexagonal Architecture · Ports & Adapters

Java 21Spring Boot 3PostgreSQL 16FlywayTestcontainers

Domain isolated from Spring Web, JPA, and Gemini infrastructure.
Flyway migrations validated in CI against real PostgreSQL.
springdoc-openapi and JWT security for production-ready API surface.

Technical decisions

Why hexagonal architecture?

The domain stays isolated from Spring DI and JPA. Swapping the Gemini adapter for another provider requires zero changes to core fitness logic.

// ports & adapters

Why Testcontainers?

In-memory databases lie about production behavior. Each suite runs against PostgreSQL 16 with real migrations; JaCoCo at 80% is a hard CI gate.

// integration > mocks alone

Why Room + Retrofit?

ViewModels observe Room Flow—they never care if data came from network or cache. The app stays usable when connectivity drops mid-workout.

// offline-first

Android · Retrofit

interface WorkoutApiService {
  @GET("api/v1/workouts/plan")
  suspend fun getWorkoutPlan(
    @Header("Authorization") token: String,
    @Query("goal") goal: String,
  ): Response<WorkoutPlanDto>
}

Backend · Spring Controller

@RestController
@RequestMapping("/api/v1/workouts")
public class WorkoutController {
  @GetMapping("/plan")
  public ResponseEntity<WorkoutPlanDto> getWorkoutPlan(
      @RequestHeader("Authorization") String token,
      @RequestParam String goal) {
    return ResponseEntity.ok(service.getWorkoutPlan(goal));
  }
}

Google Gemini behind ports

AI logic lives in infrastructure adapters. The domain calls ports like AiGeneratorPort without knowing the provider; prompts stay in dedicated builders.

GeminiGeneratorAdapterAiGeneratorPort
GeminiCoachAdapterAiCoachPort
GeminiFoodVisionAdapterFoodVisionPort
GeminiNutritionAnalysisAdapterNutritionAnalysisPort
GeminiEducationAdapterEducationAiPort
GeminiShoppingListAdapterShoppingListAiPort
GeminiSubstitutionAdapterSubstitutionAiPort

Domain port

public interface AiGeneratorPort {
  WorkoutPlan generateWorkoutPlan(UserProfile profile);
  NutritionPlan generateNutritionPlan(UserProfile profile);
}

Live demo

Try the Android client on Appetize — the demo opens in a new browser tab.

Launch live demo

See how I approach design decisions