Ricardo Malosso
Full Stack Developer
12years in Frontend
6/10API Design
5years with Bootstrap
5repositories checked by code analysis
Overview
Full Stack Developer at Freelance, with 12 years of work experience. Previously Systems Analyst II at Wipro and Bilingual Service Desk Analyst at CGI Group. Works with Python, FastAPI, Uvicorn, Pydantic, Asyncio and HTTPX.
Phone
Timeline
Full Stack Developer
·
Middle
Freelance
·
Freelance
Developed and maintained web applications across front-end and back-end, including a rewards program that served thousands of users. Built solutions using C#/.NET and Python with API integrations, and added AI features such as LLM-based functionality and voice generation. Provided programming and systems maintenance support for Primecomm.
C#
JavaScript
Node JS
React.js
Rest API
LLM
Text-to-Speech
FFmpeg
Systems Analyst II
·
Middle
Wipro
·
Full-Time
Worked on the development and maintenance of Itaú’s mortgage lending portal within an eight-person team. Implemented features and API integrations using C# and .NET, including ASP.NET MVC and Web API. Contributed to front-end updates using HTML5, JavaScript, and Bootstrap, and assisted the team in diagnosing and resolving application issues.
C#
ASP.NET Core
Rest API
JavaScript
Bootstrap
Bilingual Service Desk Analyst
·
Middle
CGI Group
·
Full-Time
Provided technical support in Portuguese and English via phone, chat, email, and service portal. Resolved Windows and application/access issues using remote support and managed software setup and Active Directory access permissions. Tracked incidents through BMC Remedy and ServiceNow and supported basic SAP cases with collaboration from technical teams.
Active Directory
ServiceNow
Windows
Universidade de Mogi das Cruzes (UMC)
Bachelor's Degree ·
Information Systems
Projects
Web Portfolio with Admin Panel
Designed and built a web portfolio with Portuguese and English versions using React, Vite, and Node.js. Implemented an admin panel with Google authentication and added API documentation using Swagger. Used Prisma with SQLite to support the application backend and data access.
Created an AI-powered Firefox extension that customizes web pages using natural language commands. Integrated the Gemini API and prepared DOM context to guide changes while providing a chat-style interface for user confirmations. Implemented element selection, previews, and logic to reapply customizations after reloads, with context processing to limit exposed page content.
Developed a dashboard showing Brazilian election results at national and state levels using official TSE data. Implemented shared caching to reduce repeated data requests and added adaptive polling based on vote-counting progress. Created result progression visualizations and an overlay interface suitable for OBS broadcasts.
Built a local speech synthesis and voice cloning application using Python and the OmniVoice model. Implemented voice generation workflows with audio processing and playback, plus user features like history and generation progress tracking. Added packaging and automation through Windows installer support, automated tests, and CI/CD, with additional features for Twitch integration and remote access.
Technical skills
Languages
7
JavaScript
C#
Node JS
Python
TypeScript
SQL
C
Python
4
FastAPI
Pydantic
Asyncio
HTTPX
Other
25
React.js
FFmpeg
LLM
Bootstrap
Rest API
Active Directory
ASP.NET Core
Windows
Text-to-Speech
React Router
Entity Framework Core
SQLAlchemy
Uvicorn
JQuery
GitHub Actions
Gemini
i18next
Vite
GitHub
SQLite
CI/CD
Git
Prisma
Swagger
Dependency Injection
Backend Developer
Code level: Senior Confidence: Medium API Engineer
A pragmatic Senior-level backend engineer focusing on robust local inference orchestration and real-time API surfaces with strong end-to-end test coverage. The strongest proven skill is building resilient local TTS/inference orchestration and real-time event plumbing, demonstrated by the engine lifecycles, worker/process runner code and the extensive tests under src/pacttsclone and tests/. The public code does not show large-scale distributed deployments, formal schema migration histories, or long-running service orchestration across multiple networked microservices.
API Design
6/10
How well APIs are designed
API design shows deliberate boundary controls, token/session checks, SSE with REST fallback and meaningful test coverage, but lacks explicit documented API versioning or a uniform idempotency header strategy.
Evidence
PacTTSClone/src/pacttsclone/app.py:create_app and many /api/* endpoint handlers
PacTTSClone/tests/test_api.py:test_full_api_pipeline (end-to-end API contract tests)
PacTTSClone/src/pacttsclone/tunnel.py:Tunnel.start / snapshot usage (remote admin/player boundary handling)
Data Layer & Database
5/10
Working with databases
Data layer uses a simple SQLite-backed Store with atomic patch semantics and plenty of tests for correctness and import behavior, but there is no multi-step migration history or advanced tuned SQL visible.
Evidence
PacTTSClone/src/pacttsclone/store.py:Store.put/get/patch implementations (sqlite usage)
PacTTSClone/tests/test_v2.py:test_store_persistence_and_atomic_patch (verifies atomic persistence)
PacTTSClone/tests/test_imports.py:test_personal_import_rolls_back_staged_assets_on_destination_conflict (import/idempotency and data integrity tests)
Scalability & Performance
6/10
Handling load and speed
Good scalability and performance patterns: worker process model, queue/decoupling, SSE reduces polling and measured request reductions; caching and residency are present, though full benchmark artifacts are limited.
Evidence
PacTTSClone/src/pacttsclone/worker.py:ProcessRunner/InlineRunner and worker lifecycle (spawn, cancel, reset)
PacTTSClone/src/pacttsclone/events.py:EventDispatcher and DashboardEvents (coalescing, sampler and SSE stream semantics)
PacTTSClone/tests/browser/test_events_ui.py:test_no_eventsource_uses_slower_rest_fallback and related SSE/browser tests
System Architecture
5/10
Overall system structure
Clear module decomposition and purposeful service boundaries (engine lifecycles, runtime setup, updater bridge and tunnel), supporting graceful degradation, but this is a single-process app rather than a multi-service distributed system.
Evidence
PacTTSClone/src/pacttsclone/update_bridge.py:AppLoader / ControllerFinder (loader boundary design)
PacTTSClone/src/pacttsclone/engines.py:EngineManager coordinating Kitten/Ming lifecycles
PacTTSClone/src/pacttsclone/ming_lifecycle.py:MingLifecycle (install/activate/uninstall lifecycle separation)
Security & Auth
6/10
Protecting data and access
Security and auth are handled with attention - host-only routes, token/session boundaries, protected storage for credentials and tests ensuring secrets are not leaked; there is good input validation in many boundary cases.
Evidence
PacTTSClone/src/pacttsclone/twitch_oauth.py:TwitchAccounts and http_json (token refresh, validation, error handling)
PacTTSClone/src/pacttsclone/discord_credentials.py:DiscordWebhookCredential (protected save/forget behavior)
PacTTSClone/tests/test_tunnel.py:test_tunnel_keys_are_distinct_and_revoked and tests ensuring admin/player isolation
Reliability & Observability
6/10
Stability and monitoring
Reliability and observability are strong: structured generation metrics, per-stage timing, JSONL audit logs, graceful worker cancel/reset behavior and diagnostic logging, with tests exercising failure and recovery paths.
Evidence
PacTTSClone/src/pacttsclone/worker.py:task stages, cancel, monitor and execute_task (graceful cancel/recovery)
PacTTSClone/tests/test_request_audit.py:test_vram_warning_threshold_and_transition_logging (per-stage metrics and audit)
PacTTSClone/src/pacttsclone/ming_runtime_worker.py:uses RotatingFileHandler and diagnostic emit patterns
Expertise
Backend AI & LLM· Middle
Messaging & Real-time· Senior
Microservices & API Architecture· Middle
Python· Middle
Technologies
Python· since 2026 · Senior
Rest API· since 2014
FastAPI
Asyncio
Pydantic
HTTPX
Uvicorn
Recommendations
- Develop local inference orchestration and worker lifecycle features that manage isolated runtimes and resumable installs (device-level TTS engines and process runners).
- Build and maintain real-time event integrations and web UI backplanes (SSE with fallback, EventSub handling and tunneled admin/player boundaries).
- Extend robust API boundaries and token/session controls for remote-capability features, focusing on explicit idempotency and versioning for public endpoints.
- Implement formal schema migrations and documented migration history if expanding persistent data models beyond the current sqlite Store.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Frontend Developer
Code level: Middle Confidence: High UI Engineer
Frontend web engineer (Middle) focused on polished, accessible static sites and client-side UI for media-rich pages. The strongest proven skill is building robust client-side media and subtitle handling, as shown by the SRT/LRC parsing and lyric-alignment logic in src/lyrics.ts and src/lrclib.ts. There is limited public evidence of advanced runtime state management, end-to-end test coverage, backend/API design or measured performance optimizations.
UI Component Architecture
4/10
How interface parts are built
Separation of concerns is present (data, i18n, parsing) and small, well-scoped helper modules exist, but there is limited evidence of a deliberate component library, advanced composition patterns, or custom design-system primitives authored from scratch.
Evidence
PacBlog/src/data.ts: routeMetadata and routes generation separating routing/data from UI
PacBlog/src/i18n.ts: createI18n - centralized localization resource setup
PacBlog/src/lyrics.ts: parsing and timeline utilities (activeRow, selectedRow) kept as standalone logic
Responsive & Cross-browser
6/10
Works on all screens and browsers
Responsive and cross-browser considerations are clearly applied with fluid type (clamp), multiple breakpoints, prefers-reduced-motion handling, and explicit i18n hooks.
Evidence
PacBlog/src/styles/global.css: use of clamp(), multiple responsive @media breakpoints and detailed layout adjustments
PacBlog/src/styles/global.css: @media(prefers-reduced-motion:reduce) block disabling transitions
PacBlog/src/i18n.ts: locales array and createI18n showing multi-locale readiness
Performance Optimization
3/10
Speed of the interface
Basic build-time performance awareness (static prerendering and content pre-generation) but no measured optimizations, bundle analysis artifacts, or runtime performance strategies beyond static export.
Evidence
PacBlog/package.json: build script runs content generation, tsc and Vite SSR build and a prerender step
PacBlog/src/data.ts: content imported from content.generated.json indicating precompiled content usage
Accessibility & Semantics
6/10
Usable for everyone
Multiple deliberate accessibility affordances are present (focus-visible outlines, skip link, sr-only utilities, keyboard help text and reduced-motion respect), demonstrating meaningful attention to semantics and keyboard users.
Evidence
PacBlog/src/styles/global.css: focus-visible rules and .sr-only / .skip styles for keyboard navigation
PacBlog/src/styles/global.css: explicit prefers-reduced-motion media query and reduced transition rules
PacBlog/src/i18n.ts: keyboard help text and descriptive copy for keyboard interactions
State Management & Data Flow
3/10
Managing data in the app
Reasonable client-side state utilities for a static site and deterministic lyric timeline functions are present, but no evidence of advanced async state discipline (cancellation, optimistic updates or server-state caching strategies).
Evidence
PacBlog/src/lyrics.ts: activeRow, selectedRow, nearbyRow and formatTime - deterministic timeline/state helpers
PacBlog/src/data.ts: content and routes generation plus alternatePath/routeMetadata which centralize route-data mapping
UX & Visual Polish
6/10
Look and feel quality
High visual polish and UX detail for the music/lyrics player and general site UI, including states (player-error, player-status), transitions, fullscreen lyric UX and attention to perceived performance.
Evidence
PacBlog/src/styles/global.css: player controls, lyric-highlight transitions, fullscreen-lyrics and detailed player layout styles
PacBlog/src/styles/global.css: classes for player-error/player-status and interactive controls (play-control, music-seek, lyric-controls)
Expertise
React· Middle
HTML & CSS· Middle
Modern Web Frameworks· Middle
Technologies
Node JS· since 2014 · Middle
Prisma· since 2026
Bootstrap· since 2021
React.js· since 2014
JQuery
Vite· since 2026
i18next
React Router
Recommendations
- Develop static, content-driven React sites and interactive media pages that need careful UX and accessibility (music players, transcripts, bilingual content).
- Implement front-end features that require robust client-side parsing and synchronization (timed subtitles, lyric alignment, media overlays).
- Work on component-level UI polish, theming and responsive design tasks where accessibility and visual detail matter.
- Contribute to localization and content pipelines (i18n, prerendering, content generation) for multilingual static sites.
QA Engineer
Code level: Middle Confidence: Medium Generalist
A generalist software developer focused on web frontends, text and audio processing, and small tooling scripts at a solid middle level of practical competence. The strongest proven skill is careful parsing and data handling as shown by the PacBlog lyric parsing and alignment code (src/lyrics.ts and src/lrclib.ts) and the safe PDF footer linker (scripts/link-resume-pdfs.py). The public code shows limited or no formal test suites, CI workflow artifacts under the analyzed files, or dedicated QA infrastructure such as contract tests or load test scenarios.
Test Automation Frameworks
1/10
Building automated tests
Minimal test automation artifacts visible; a test script is declared but no test harnesses, fixtures or mock servers are present in the analyzed human-authored files.
Evidence
PacBlog/package.json: "test" script -> "node --test tests/*.test.mjs"
Test Coverage & Strategy
2/10
What and how to test
Some defensive checks and explicit error throwing exist in parsing code, but there is no visible risk-based test structure, negative-path test suite, or property-based tests in the provided human-authored files.
Evidence
PacBlog/src/lyrics.ts: parseSrt throws descriptive errors for invalid SRT cues
PacBlog/package.json: test script references tests/*.test.mjs but no test files were provided
API & Integration Testing
1/10
Testing how parts work together
No contract or integration test tooling is present; API/integration testing patterns (schema validation, idempotency tests, testcontainers) are not evidenced.
Evidence
PacBlog/package.json: no contract testing libraries configured
No files referencing pact, schemathesis, or testcontainers in the analyzed files
Performance & Load Testing
2/10
Testing speed under load
Very limited performance awareness; algorithm comments indicate scale testing, but there are no formal load scenarios, thresholds or performance tooling.
Evidence
Drone_Ricardo_Velozient_/index.js: comment 'tested with up to 10000 locations' indicating some scale consideration
No load-testing tools or scripts (k6, locust, gatling) in the analyzed files
Bug Reporting & Analysis
2/10
Finding and describing bugs
Evidence of pragmatic defensive programming and safe file handling exists, but there are no linked bug reports, RCA artifacts or documented flaky-test investigations.
Evidence
PacBlog/scripts/link-resume-pdfs.py: writes to a temporary file then replaces original to avoid corruption
PacBlog/src/lyrics.ts: parseSrt throws explicit errors on malformed input
CI Test Integration
1/10
Running tests automatically
CI intent and build steps are visible in metadata, but no CI workflow files or test-run integration artifacts were present in the analyzed human-authored files to demonstrate per-matrix test orchestration, selective runs or failure artifact collection.
Evidence
PacBlog/package.json: build and test scripts (build runs content generation, tsc and vite) indicate CI-oriented scripts
No GitHub Actions workflow files or equivalent CI config were included in the analyzed files
Industries
Media & Entertainment· Middle
Software· Middle
Transportation & Logistics· Middle
Technologies
JavaScript· since 2014 · Middle
TypeScript· Middle
SQL
C#· since 2014 · Middle
Swagger
SQLAlchemy
GitHub Actions
CI/CD
Git
ASP.NET Core· since 2021
Entity Framework Core
GitHub
Windows· since 2014
Recommendations
- Develop static content sites and UI features that need robust text parsing, internationalization and accessible components (work leveraging the TypeScript React code and lyric parsing utilities).
- Implement and harden small command-line or automation scripts that manipulate files safely, e.g., tooling that patches PDFs or prepares build artifacts like the existing link-resume-pdfs.py.
- Prototype algorithmic features and small back-end utilities such as route packing or scheduling logic where the existing drone bin-packing code demonstrates a pragmatic approach to constraints.
- Collaborate on frontend features that require careful edge-case handling for media timelines, subtitle alignment and format conversion, using and extending the lrclib/lyrics utilities.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Job preferences
- Work permits
- Brazil
Open to AI agents: they read this profile and start a dialog through Alion
alion.io/@ricardo-malosso/mcpAlion · People, companies and AI agents in one graphalion.io/@ricardo-malosso