Build intern project app using Android + Backend frameworks

[alper4283]

Description

We need to implement an application based on the instructions in the intern-project-engineering GitHub repository READMEs, using the company-provided Android and Backend frameworks end-to-end. This work ensures the frameworks are correctly applied in a real project context and helps validate developer experience, integration clarity, and production readiness.

In addition to delivering the functional app, this initiative includes identifying concrete improvement opportunities in both frameworks while actively using them. The result will reduce onboarding friction for future interns/engineers, uncover integration gaps early, and produce actionable recommendations to improve usability, stability, and documentation quality.

Assumption: The required implementation details and required features are fully specified in the repository READMEs. No additional requirements are assumed beyond the README scope.

Ownership, Deadline & Effort

• Team Owner: Engineering
• Individual Owner: Alper Koyuncu
• Deadline: 2026-01-24 24:00 (end of day, non-negotiable)
• Estimated Effort: 15 hours

Deliverables

1. Android application implemented per repository README requirements, using the provided Android framework throughout.
2. Backend service implemented per repository README requirements, using the provided backend framework throughout.
3. Integrated end-to-end workflow verified (Android ↔ Backend) and demonstrated with a reproducible run flow.
4. Visually appealing UI applied across the Android app (consistent styling, layout polish).
5. A written document (minimum 5 pages and minimum 1000 words) describing improvement suggestions for:
   • Android framework
   • Backend framework
     Including specific pain points encountered during implementation and actionable recommendations.

Scope

In Scope

• Implement all app features defined in the intern-project-engineering repo READMEs.
• Use the internal Android framework for Android implementation (no substitution of core framework components).
• Use the internal backend framework for backend implementation (no substitution of core framework components).
• UI improvements to ensure the app is visually appealing:
  • coherent typography, spacing, color usage
  • consistent component styling
  • polished UX flow (within README-defined screens/flows)
• Integration validation:
  • confirm Android app successfully communicates with backend per README flow
  • verify main flows succeed without manual hacks
• Produce the improvement suggestions document (5+ pages, 1000+ words).

Out of Scope

• Adding “every possible improvement” beyond the README-defined feature set (unbounded scope).
• Introducing new product features that are not described in the READMEs.
• Replacing internal frameworks with third-party alternatives.
• Major redesign of product behavior not implied by README requirements.
• Infrastructure changes unrelated to running the app locally or in the expected dev environment (e.g., Kubernetes, CI migration), unless required by README.

Scope clarification: The phrase “every possible improvements” is treated as UI polish + sensible quality upgrades (performance, stability, DX), not adding new features beyond the README.

Acceptance Criteria

• Android app satisfies all functional requirements listed in the repository READMEs.
• Backend implementation satisfies all functional requirements listed in the repository READMEs.
• Internal Android framework is used throughout the Android app (no core substitution).
• Internal backend framework is used throughout the backend (no core substitution).
• Android ↔ Backend integration works end-to-end following README run instructions.
• App builds and runs successfully from a clean checkout using documented setup steps.
• UI is visually polished and consistent across all implemented screens:
  • consistent spacing/alignment
  • consistent typography
  • no obvious layout regressions (overlaps, clipped text, broken scroll)
• Improvement suggestions document is completed and shared:
  • minimum 5 pages
  • minimum 1000 words
  • includes both frameworks
  • recommendations are actionable and based on observed issues during implementation

Domain-Specific Notes

Engineering

• Constraint: Framework usage is mandatory throughout the project.
• Dependency: Implementation requirements and run instructions are defined in the repository READMEs.
• Assumption: Repo provides or references required environment variables, API endpoints, and setup steps.
• Quality expectation: No critical runtime crashes on main flows; clean logging; reasonable error handling for failed network operations.

Design

• UI requirement: “Visually appealing” interpreted as consistent and polished UI within the existing screen/feature requirements.
• Assumption: No existing design system file is provided; use framework-compatible theming patterns.

Validation / Review Requirements

• Validation method:
  • Manual end-to-end run validation following README setup steps (fresh clone scenario).
  • Basic sanity testing of main user flows as defined by the README.
• Required review:
  • Engineering review of code changes (Android + Backend).
  • Review of improvement document for actionable clarity.
• Definition of “done”:
  • All deliverables completed.
  • All acceptance criteria checked off.
  • Work is reproducible from README instructions without undocumented steps.

Additional Context

• Repo: intern-project-engineering
• Owner: alper4283