Loopyfeed

LoopyFeed’s feed system dynamically adapts to user interactions such as watch duration, replays, skips, and session timing. By prioritizing reels that users naturally loop or watch longer, the system gradually learns individual sensory preferences and surfaces content that maximizes calmness and engagement.

The backend of LoopyFeed is composed of Python-based microservices that handle content processing, reel metadata generation, recommendation logic, and QR code creation. These services are designed to be modular and scalable, ensuring reliable performance as the platform grows.

A dedicated Python microservice generates unique QR codes for each ASMR reel. These QR codes allow creators to share reels externally, drive traffic back to the app, and support offline-to-online discovery. Each QR code is securely linked to reel metadata and deep links directly into the LoopyFeed app.

FastAPI (Python)

1async def convert_svg_to_png(
2    file: UploadFile = File(...),
3    authorization: str = Header(None),
4    x_dune_key: str = Header(None)
5):
6    if not authorization or not authorization.startswith("Bearer "):
7        raise HTTPException(status_code=401, detail="Missing or invalid Authorization header.")
8
9    token = authorization.removeprefix("Bearer ").strip()
10    validate_key(x_dune_key)
11
12    try:
13        user_data = decrypt_and_validate_token(token)
14        logger.info(f"Decoded token for user: {user_data}")
15    except Exception:
16        raise HTTPException(status_code=403, detail="Invalid token.")
17
18    if not file.filename or not file.filename.lower().endswith(".svg"):
19        raise HTTPException(status_code=400, detail="Only .svg files are supported.")
20
21    try:
22        svg_content = await file.read()
23        png_io = io.BytesIO()
24        cairosvg.svg2png(bytestring=svg_content, write_to=png_io)
25        png_io.seek(0)
26
27        output_filename = file.filename.lower().replace(".svg", ".png")
28
29        return StreamingResponse(
30            png_io,
31            media_type="image/png",
32            headers={"Content-Disposition": f"inline; filename={output_filename}"}
33        )
34
35    except Exception:
36        logger.exception("Failed to convert SVG to PNG")
37        raise HTTPException(status_code=500, detail="Failed to convert SVG to PNG.")

LoopyFeed uses Firebase for user authentication, real-time data syncing, notifications, and media metadata storage. Neon (PostgreSQL) is used for structured relational data such as creator analytics, engagement metrics, and internal platform insights. This hybrid approach balances real-time performance with robust analytical capabilities.

Flutter(Dart)

1
2Future<Object> signUp(String email, String password) async {
3    try {
4      final response = await _dio.post(
5        '$baseUrl/auth/sign-up',
6        data: {
7          'email': email,
8          'password': password,
9        },
10        options: Options(
11          headers: {'Content-Type': 'application/json'},
12        ),
13      );
14
15      if (response.statusCode == 201) {
16        return true;
17      } else {
18        return response.data['message'] ?? 'Failed to sign up';
19      }
20    } catch (e) {
21      if (e is DioException && e.response != null) {
22        return e.response?.data['error'] ?? 'An error occurred during sign up';
23      }
24      print('SignUp Error: $e');
25      return 'An unexpected error occurred';
26    }
27  }
28  Future<List<Reel>> fetchReelsData() async {
29    try {
30      final response = await _dio.get('$baseUrl/reels/carousel');
31
32      if (response.statusCode == 200) {
33        List<dynamic> jsonData = response.data;
34        List<Reel> reels = await Future.wait(jsonData.map((e) async {
35          Reel reel = Reel.fromJson(e);
36          await reel.initializeDynamicFields();
37          return reel;
38        }).toList());
39
40        return reels;
41      } else {
42        throw Exception('Failed to load reel data');
43      }
44    } catch (e) {
45      throw Exception('Error: $e');
46    }
47  }                 

The LoopyFeed mobile app is built with Flutter, enabling a single, high-quality codebase for both iOS and Android. The UI focuses on vertical swipe navigation, instant reel looping, haptic feedback, and minimal controls to maintain a calming experience. Performance optimizations ensure smooth playback even on lower-end devices.

LoopyFeed incorporates a deeply instrumented analytics system designed to understand user behavior at a granular level. The platform tracks a wide range of interaction signals including loop frequency, total and average watch time, scroll velocity, retention drop-off points, replay patterns, and trigger-specific engagement. These metrics go beyond surface-level views and likes, offering a behavioral understanding of how users consume ASMR content. Data is aggregated and processed to generate meaningful insights such as which trigger combinations sustain attention longer, what reel durations maximize looping behavior, and how different sensory categories perform across time-of-day or session context. Through the creator dashboard, these insights are presented via clear visualizations, comparative benchmarks, and historical trends. This empowers creators to iterate scientifically on their content, align production with audience preferences, and consistently improve performance through data-backed decisions.

TypeScript

1
2        <Form {...form}>
3            <form onSubmit={form.handleSubmit(onSubmit)} className="grid grid-cols-1 lg:grid-cols-2 xl:gap-20">
4                <ReelInput form={form} />
5                <ReelMetadataInput form={form} />
6                <ReelAdditionalSettingsInput form={form} />
7                <Button
8                    type="submit"
9                    className="mt-5 lg:mt-0 lg:col-span-2 max-w-full md:max-w-[300px] lg:max-w-[300px] rounded-full lg:py-[30px] p-[30px] place-self-center w-full cursor-pointer"
10                >
11                    <span className="text-2xl">
12                        Upload
13                    </span>
14                </Button>
15            </form>
16        </Form>

LoopyFeed follows a modern, production-grade CI/CD strategy that prioritizes stability, speed, and scalability. Every code change passes through automated testing pipelines that validate functionality across Flutter mobile builds, the Next.js web dashboard, and Python-based backend services. Successful builds are automatically prepared for release, significantly reducing manual overhead and deployment risk. Mobile applications are versioned and distributed via the Apple App Store and Google Play Store, ensuring compliance with platform guidelines and smooth user updates. The creator dashboard benefits from continuous deployment on cloud infrastructure, enabling rapid UI iterations and instant rollbacks. Backend microservices are containerized and deployed independently, allowing critical services such as QR code generation or analytics processing to scale horizontally based on demand without affecting the core user experience.

GitHub Actions(YAML)

1
2      - name: Download backup artifact
3        uses: actions/download-artifact@v4
4        with:
5          name: database-backup
6
7      - name: Set up Python
8        uses: actions/setup-python@v5
9        with:
10          python-version: '3.x'
11
12      - name: Install Python dependencies
13        run: |
14          pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib
15
16      - name: Create credentials file
17        run: |
18          echo "{{ secrets.GDRIVE_CREDENTIALS }}" | base64 -d > credentials.json

LoopyFeed’s design philosophy is guided by the principles of calmness, intentional simplicity, and sensory balance. The interface is deliberately understated, using muted color palettes, soft gradients, and low-contrast elements to avoid visual fatigue during extended viewing sessions. Dark-mode-first design ensures comfort in low-light environments, which are common during nighttime or relaxation use cases. Animations and transitions are subtle and purposeful, reinforcing the looping nature of content without drawing attention away from the ASMR itself. Controls are minimized and revealed contextually, allowing users to remain immersed in the experience. This approach ensures that the app feels less like a traditional social platform and more like a tranquil, personal space for relaxation and focus.

LoopyFeed is engineered with a forward-looking architecture that supports both technical and product scalability. Its modular service-oriented backend allows new capabilities to be introduced independently, whether they involve advanced analytics, recommendation enhancements, or creator tools. The data models are flexible enough to support richer metadata, emerging ASMR categories, and evolving user interaction patterns. Looking ahead, LoopyFeed is positioned to introduce features such as AI-driven trigger classification, mood-aware and context-sensitive feeds, creator monetization systems, and collaborative or session-based ASMR experiences. This long-term vision ensures that LoopyFeed can grow from a reels-based app into a comprehensive sensory media platform while maintaining performance, reliability, and a calm user experience at scale.