Gonzalo Secades
Frontend Developer
8+ years exp
10+ projects
TypeScript
Go
Node JS
JavaScript
API Design: 4/10
System Architecture: 4/10
Active 26 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend API engineer (middle level) focusing on API-backed document parsing and developer tooling with a strong pragmatic approach to provider abstraction and error handling. The strongest proven skill is building a pluggable LLM-backed parsing pipeline with validation and a Supabase + in-memory persistence fallback as shown in tickygram/apps/api/src/services/documentParsing.ts and tickygram/apps/api/src/services/supabase.ts. There is limited evidence of high-scale architecture, production-grade observability, formal schema migration chains, or distributed-systems design in the human-authored files examined.
Phone
Technical skills
Languages
4
TypeScript
Go
Node JS
JavaScript
Node JS
8
Axios
Bcrypt
Passport.js
Express
TypeORM
Mongoose
Sequelize
Nest.JS
Frontend
10
Angular
React.js
Tailwind CSS
Next.js
Bootstrap
AG Grid
Zustand
Webpack
TanStack Router
TanStack Form
DevOps
4
GitHub
Git
Rest API
Jenkins
Databases
3
MongoDB
PostgreSQL
MySQL
Other
8
OpenAI Codex
Claude Code
Chi
GitHub Actions
Docker Compose
Bun
Knowledge Graph
GraphRAG
Timeline
Frontend React Developer
•
Middle
MyTaskPanel Consulting
•
Freelance
Freelance developer maintaining a React-based conference operations dashboard. Fixed bugs in attendee registration, hotels, catering, budgets, and credentials workflows, including UI components backed by AG Grid tables. Collaborated to correct production issues and improve the reliability of day-to-day operations.
React.js
AG Grid
Front End Software Engineer
•
Middle
Emerios
•
Full-Time
Worked on a B2B product used by US energy and telecom providers, owning the energy-vertical geofencing workflow across admin and agent apps. Designed configurable territory and schedule rules, location checks, and corresponding API integrations. Built multi-step onboarding and customer verification flows, including a standalone Next.js verification module with testing, accessibility, and improved interactions. Tracked and fixed production issues spanning UI and API boundaries and migrated the app build from Gulp to Webpack to reduce load times.
TypeScript
Node JS
Nest.JS
Next.js
React.js
Rest API
Webpack
Full-Stack Developer
•
Middle
Alynk
•
Full-Time
Owned end-to-end account onboarding and authentication for a financial-market platform. Built NestJS APIs and React signup/sign-in flows with password recovery and reset email functionality. Integrated the RENAPER identity service for regulatory compliance, added observability to account flows, and implemented authentication strategies for email/password and social sign-in.
Nest.JS
React.js
Operations Assistant
•
Middle
Compañía de Inversiones y Mandatos S.A.
•
Full-Time
Universidad Argentina de la Empresa (UADE)
Bachelor's Degree •
Tourism and Hospitality Management
Senior Backend Developer
Confidence: Medium API Engineer
Backend API engineer (middle level) focusing on API-backed document parsing and developer tooling with a strong pragmatic approach to provider abstraction and error handling. The strongest proven skill is building a pluggable LLM-backed parsing pipeline with validation and a Supabase + in-memory persistence fallback as shown in tickygram/apps/api/src/services/documentParsing.ts and tickygram/apps/api/src/services/supabase.ts. There is limited evidence of high-scale architecture, production-grade observability, formal schema migration chains, or distributed-systems design in the human-authored files examined.
API Design
4/10
How well APIs are designed
API design shows deliberate request/response shapes, input validation, and a provider-backed route layer, but it lacks a documented versioning or idempotency strategy and is limited in scope to a single domain service.
Evidence
tickygram/apps/api/src/routes/parse.ts: route handlers using ParseJobResponseSchema and explicit HTTPException mapping
tickygram/apps/api/src/services/documentParsing.ts: createParseJob validates MIME type, size, and manages job lifecycle/status
tickygram/apps/api/src/llm/geminiDocumentParser.ts: external LLM call, explicit error handling and JSON parsing
Data Layer & Database
3/10
Working with databases
Data layer work integrates Supabase with an in-memory fallback and basic error handling; there is no evidence of migration history, complex transaction boundaries, or hand-tuned SQL in the human-authored code.
Evidence
tickygram/apps/api/src/services/supabase.ts: getSupabaseAdmin and createDocumentRepository with Supabase insert/select and memoryDocuments fallback
tickygram/packages/shared/package.json: shared Zod schemas referenced by services (contract/schema use)
Scalability & Performance
2/10
Handling load and speed
Some operational concerns are present (input size limits, single-request LLM calls, base64 payload decisions), but there is no evidence of caching/invalidation strategies, queue-based decoupling, or measured performance optimizations.
Evidence
tickygram/apps/api/src/services/documentParsing.ts: file size limit (10MB) and synchronous provider.parseDocument call
tickygram/apps/api/src/llm/geminiDocumentParser.ts: provider fetch call and explicit fallback when key is missing
System Architecture
4/10
Overall system structure
Clear separation of responsibilities (parsing service, LLM providers, repository). The Go CLI shows thoughtful UX and config management, but there is no multi-service decomposition or documented interservice contracts beyond provider interfaces.
Evidence
tickygram/apps/api/src/services/documentParsing.ts: DocumentParsingService abstraction and provider injection
tickygram/apps/api/src/llm/providerFactory.ts: provider factory (evidence of pluggable architecture)
envSwitch/cli.go: interactive CLI architecture, persistent config and execution plumbing
Security & Auth
3/10
Protecting data and access
Basic security hygiene: secrets guarded by env checks, request-body caps, and input validation. No evidence of token lifecycle controls, refresh/revoke logic, or dependency audit in the human-authored code examined here.
Evidence
tickygram/apps/api/src/services/supabase.ts: getSupabaseAdmin returns null if SUPABASE_URL or SUPABASE_SECRET_KEY missing
tickygram/apps/api/src/services/documentParsing.ts: DocumentValidationError used for explicit validation failures
tickygram/apps/api/src/__tests__/api.test.ts: test asserting unauthenticated document writes are rejected
Reliability & Observability
3/10
Stability and monitoring
Error handling and basic reliability are present (job status updates, fallback paths). Observability, structured logging, retries with backoff, and formal metrics/alerts are not evidenced in the human-authored files.
Evidence
tickygram/apps/api/src/services/documentParsing.ts: job lifecycle (processing, succeeded, failed) and errorMessage capture
tickygram/apps/api/src/services/supabase.ts: throws on Supabase errors and falls back to memory store
Expertise
Go Development• Junior
Databases & Vector Storage• Junior
Node.js• All Tiers
System Architecture• All Tiers
Industries
Artificial Intelligence• Junior
Financial Services• Junior
Technologies
Rest API• since 2021
Chi
Bun
Recommendations
- Develop pluggable backend services that ingest documents, normalize to a stable contract, and persist to Supabase or another DB with clear migration history and transactional boundaries.
- Build LLM provider adapters and robust retry/queueing around long-running parse jobs (worker queue + durable job state) to decouple user requests from LLM latency and improve scalability.
- Extend the Go CLI work into developer-facing operational tooling (local stack orchestration, deterministic migrations runner) and add structured logging/metrics for production observability.
Junior DevOps Engineer
Confidence: Medium Generalist
A practical Go generalist (middle level) who builds developer-facing CLI utilities and cross-platform build tooling with a focus on pragmatic engineering; the strongest proven skill is shipping a cross-platform interactive env-switcher CLI (envSwitch) with platform-aware build scripts. The most concrete evidence is the envSwitch package implementing an interactive Bubbletea TUI and cross-compile build scripts (envSwitch/cli.go, envSwitch/main.go, envSwitch/build-local.sh, envSwitch/build-local.ps1). Public code does not show infrastructure-level CI/CD engineering, Kubernetes/GitOps, or observed production resilience patterns in the human-authored files, so larger platform or reliability design responsibility is not evidenced here.
CI/CD Pipelines
2/10
Automated build and deploy
CI/CD Pipelines: minimal, repo includes local build and publish scripts but no reusable pipeline engineering patterns (no reusable workflows, artifact signing, or advanced gating).
Evidence
envSwitch/build-local.sh: cross-compilation build script (sets GOOS/GOARCH and runs `go build`)
envSwitch/build-local.ps1: Windows build script for producing envswitch.exe
Infrastructure as Code
Managing servers with code
Not evidenced in public code
Containerization & Orchestration
1/10
Working with containers
Containerization & Orchestration: only surface-level build/packaging artifacts for a Go binary; no orchestration, Kubernetes manifests, tuned probes, or PodDisruptionBudget evidence in the human-authored files.
Evidence
envSwitch/build-local.sh: sets GOOS/GOARCH for multi-platform binary builds
Observability & Monitoring
Watching system health
Not evidenced in public code
Reliability & Incident Response
Keeping systems up
Not evidenced in public code
Cloud & Cost Optimization
Smart use of the cloud
Not evidenced in public code
Expertise
Platform Engineering & IDP• Junior
Industries
Financial Services• Junior
Technologies
Go• since 2018 • Junior
Docker Compose
GitHub Actions
Recommendations
- Assign to developer tools and platform-utility work: build internal CLIs, developer environment orchestration, and release helper scripts (extend envSwitch into a curated dev-IDP tool).
- Have them own small cross-platform packaging and CI build jobs where Go binaries are produced and validated (expand build-local.sh into reproducible CI steps and add artifact validation and checksums).
- Pair them with a senior platform or SRE engineer to migrate the CLI's build steps into reusable GitHub Actions workflows and to instrument publish gating and artifact signing.
Junior Security Engineer
Confidence: Medium Generalist
Developer Tools Engineer (mid-level) focused on cross-platform CLI and TUI utilities with pragmatic error handling. The strongest proven skill is building a robust interactive environment-switcher in Go, evidenced by envSwitch/cli.go (Bubbletea TUI, persistent config, path validation) and envSwitch/main.go (dry-run, format-specific replacement logic). The public code does not evidence backend web API security work, cryptography, vulnerability research, or detection/IR capabilities.
Vulnerability Analysis
1/10
Finding security weaknesses
Minimal vulnerability-awareness in general-purpose CLI code (basic input and file existence checks); no dedicated root-cause vulnerability analysis, exploitability proofs, or PoCs present in the human-authored files.
Evidence
envSwitch/main.go: executeSwitchNew checks for config and target file existence and returns clear errors
envSwitch/cli.go: savePersistentConfig / loadPersistentConfig handle file-read/write error paths
Cryptography & Secure Protocols
Using encryption correctly
Not evidenced in public code
Offensive Security / Pentesting
Testing by attacking
Not evidenced in public code
Defensive Hardening
2/10
Making systems harder to break
Some defensive hardening practices for a CLI tool are present (file existence checks, dry-run mode, conservative writes), but no systematic least-privilege, sandboxing, secrets management, or security regression tests.
Evidence
envSwitch/main.go: supports --dry-run to preview changes and printDiff to show replacements
envSwitch/cli.go: executeSwitchNew validates config file presence and target path before writing
Detection & Incident Response
Spotting and handling attacks
Not evidenced in public code
Compliance & Threat Modeling
Planning against threats
Not evidenced in public code
Recommendations
- Lead small to medium CLI or developer-experience features: interactive tools, environment/sync utilities, and cross-platform build helpers (use envSwitch as the base).
- Harden the tool for hostile inputs: add explicit path normalization, safe-write (atomic write-with-tempfile), and unit tests for JS parsing edge cases before using it to patch production config files.
- Add targeted tests and CI checks for the replacement logic and dry-run mode, including regression cases for JS-format parsing and unmatched brace scenarios.
- If asked to work on security-sensitive projects, pair with an application-security engineer to add threat modeling, secrets handling, and security regression tests.