Journey

Looking Back

After more than four years of learning programming, I’m taking time to reflect on my journey and what I’ve learned about software engineering.

What I’m Realizing

Software should solve real problems: The best projects are the ones that actually help people or solve meaningful challenges.

Learning never stops: Technology evolves constantly. Being a good developer means being a continuous learner.

Fundamentals matter more than frameworks: Frameworks come and go, but understanding core concepts lasts.

Code quality matters: Writing code that works is just the first step. Writing code that others can understand and maintain is the real skill.

Collaboration is essential: While I’ve learned a lot independently, I recognize that professional development is a team sport. AI supports this mindset by helping me brainstorm and document decisions clearly so collaboration is smoother.

What I Want to Learn Next

Professional team experience: I want to work with experienced engineers and learn how professional teams operate.

Large-scale systems: I want to understand how systems work at scale, not just in practice projects.

Code review culture: I want to learn from code reviews and improve through feedback.

Production systems: I want to experience deploying, monitoring, and maintaining real production systems.

Mentorship: I want to learn from senior engineers who can guide my growth.

Why I’m Seeking a Junior Position

Despite my technical knowledge, I recognize that I lack professional experience. I want to:

• Learn from experienced engineers
• Work on real products with real users
• Understand professional development workflows
• Grow within a team environment
• Apply my knowledge to solve real business problems

My Commitment

I’m committed to continuous learning and improvement. I take software engineering seriously and want to build a long-term career in this field.

I’m looking for a team that values learning, code quality, and collaboration where I can contribute while continuing to grow.

The Experience

In February 2025, I’m participating in the Camballey Hackathon another opportunity to build something quickly with a team.

After my NASA Space Apps experience, I feel more prepared for the hackathon format, but it’s still challenging.

What We’re Building

Our team is developing a solution to improve public transportation in my hometown, Santa Cruz de la Sierra, Bolivia. Many commuters struggle with unclear routes, limited real-time information, and inefficient connections between transport options.

The process involves:

• Brainstorming and validating ideas quickly
• Dividing responsibilities among team members
• Building a working prototype
• Preparing a presentation for judges

We use AI to draft requirement maps and outline the pitch, keeping communication crisp while we iterate fast.

What I’m Learning

Execution beats perfect ideas: Many teams have interesting ideas, but the ones that ship working prototypes stand out.

Time constraints force prioritization: We have to focus on core features and cut everything else.

Team dynamics matter: Clear communication and defined roles help us move faster.

MVP thinking is essential: Building the minimum viable product first, then adding features if time allows.

Improvements from Last Time

• Better time management
• More realistic scope planning
• Clearer team communication
• Faster decision-making

Challenges

• Balancing feature completeness with time constraints
• Integrating different parts of the solution
• Staying focused under pressure
• Managing energy over the event duration

Growth

This experience is reinforcing:

• Rapid prototyping skills
• Team collaboration abilities
• Product thinking and prioritization
• Presentation skills

Completing My Degree

In late 2025, I’m completing my Computer Engineering degree at UAGRM. In early March 2026, I’ll receive my official title.

Over the past five years, I’ve combined formal education with intensive self-directed learning. I’ve built dozens of projects, learned multiple technologies, and developed a deep understanding of software engineering principles.

What I’ve Learned

Throughout my journey, I’ve gained experience with:

Frontend Development: React, TypeScript, responsive design, modern CSS Backend Development: Node.js, Express, API design, authentication Databases: PostgreSQL, MongoDB, database modeling, query optimization Tools & Practices: Git, testing, debugging, documentation, code review

I’ve also developed strong problem-solving skills and the ability to learn new technologies quickly.

Why I’m Seeking a Junior Position

Despite my technical knowledge and experience with independent projects, I recognize that I lack professional team experience. I haven’t worked in a real company environment where I can:

• Collaborate with experienced engineers daily
• Work on large-scale production systems
• Follow established engineering practices and workflows
• Participate in code reviews and learn from senior developers
• Contribute to a product with real users and business impact

I’m specifically seeking a junior position because I want to learn from experienced professionals and grow within a structured team environment.

My Approach to Projects

Over the years, I’ve built many projects for learning purposes. Most of them I’ve deleted because they served their purpose teaching me specific concepts or technologies. I focused on learning and improving rather than accumulating portfolio pieces.

The projects I’ve kept are the ones that demonstrate meaningful problem-solving or technical depth.

What I’m Looking For

I’m seeking a junior software engineer position where I can:

• Work with experienced engineers who can mentor me
• Contribute to real products that impact users
• Learn professional development practices
• Grow my skills in a collaborative environment
• Apply my strong technical foundation to solve real business problems

My Commitment

I’m a dedicated learner who takes software engineering seriously. I’ve spent years building my skills independently, and now I’m ready to apply that knowledge in a professional setting.

I’m looking for a team that values continuous learning, code quality, and collaboration where I can contribute while continuing to grow as an engineer.

I use AI to organize my study plans and draft documentation so I can communicate clearly with teams.

The Experience

In October 2024, I’m participating in the NASA Space Apps Challenge a global hackathon where teams build solutions using NASA’s open data.

This is my first major hackathon experience, and it’s teaching me a lot about:

• Working with a team under time pressure
• Building something functional in 48 hours
• Presenting technical ideas to judges
• Collaborating with people I just met

What We’re Building

Our team is building a prototype that [uses NASA data to solve a specific challenge]. We have to:

• Quickly understand the problem
• Divide work among team members
• Integrate different parts of the solution
• Present our work effectively

We also use AI assistants to brainstorm directions and draft technical notes, so communication stays clear while we move fast.

What I’m Learning

Speed matters in hackathons: We have to make quick decisions and move fast. Perfect code isn’t the goal working code is.

Collaboration is key: Working with teammates I just met requires clear communication and flexibility.

Scope management is crucial: We have to cut features to finish on time. Prioritization is essential.

Presentation matters: Building something great doesn’t matter if you can’t explain it clearly.

Challenges

• Time pressure is intense
• Integrating work from multiple people is tricky
• Some technical challenges are taking longer than expected
• Balancing sleep, food, and coding is hard

Growth

This experience is helping me develop:

• Rapid prototyping skills
• Team collaboration under pressure
• Ability to work with unfamiliar teammates
• Presentation and communication skills

Expanding My Knowledge

As I progress through university and continue self-study, I want to understand more advanced backend concepts.

I’m studying:

• RESTful API design principles
• Database indexing and query optimization
• Caching strategies (Redis, in-memory caching)
• Authentication patterns (JWT, OAuth)
• Error handling and logging
• API versioning and documentation

Learning Approach

Most of this learning is through:

• Online courses and tutorials
• Reading technical blogs and documentation
• Building practice projects to apply concepts
• Studying open source codebases

I understand these concepts theoretically, but I haven’t applied them at scale in a production environment.

What I’m Learning

API design is about contracts: Good APIs are predictable, well-documented, and easy to use.

Database performance matters: Proper indexing and query optimization can make huge differences.

Caching is powerful: Understanding when and how to cache can dramatically improve performance.

Error handling is crucial: Production systems need robust error handling and logging. I use AI to outline logging schemas and draft test scenarios before implementing them.

The Gap

While I understand these concepts, I haven’t experienced:

• Debugging performance issues in production
• Scaling systems to handle real traffic
• Working with large, complex databases
• Collaborating with a team on API design

This is why I’m seeking a junior position to learn how these concepts apply in real-world scenarios.

Growth Focus

During this period, I’m concentrating on:

• Understanding backend architecture patterns
• Learning database optimization techniques
• Studying API design best practices
• Building projects that demonstrate these concepts

Going Deeper

After building a solid foundation, I want to understand more advanced concepts that senior engineers work with.

I’m studying:

• System design principles
• Database optimization techniques
• Caching strategies
• API design patterns
• Performance optimization
• Security best practices

This is mostly theoretical learning through courses, books, and documentation, since I don’t have access to large-scale production systems.

What I’m Learning

System design is about trade-offs: There’s no perfect solution, only trade-offs between different approaches.

Performance matters: Understanding how to optimize queries, reduce load times, and handle scale is important.

Security is complex: There are many layers to security, from authentication to data protection to preventing common vulnerabilities.

Architecture patterns exist for a reason: Patterns like MVC, microservices, and event-driven architecture solve specific problems. I use AI assistants to compare architectural options and outline trade‑off matrices before I make decisions.

The Gap I Recognize

While I understand these concepts theoretically, I haven’t applied them in a real production environment with:

• Large-scale systems
• Real performance constraints
• Actual security requirements
• Team collaboration on architecture decisions

This is why I’m seeking a junior position to learn how these concepts apply in practice.

Growth Focus

During this period, I’m concentrating on:

• Understanding system design principles
• Learning about scalability and performance
• Studying security best practices
• Reading about architectural patterns
• Preparing for professional work

Beyond “Just Making It Work”

After building many projects, I’m realizing that making code work is just the first step.

Professional developers need to write code that:

• Other developers can understand
• Can be maintained over time
• Follows consistent patterns
• Is well-documented

I’m starting to focus on these aspects of software development.

What I’m Learning

Readable code matters: Code is read more often than it’s written. Clear variable names, good structure, and comments make a huge difference.

Consistency is important: Following consistent patterns makes codebases easier to navigate.

Testing helps: While I’m still learning testing, I understand why it’s important for catching bugs early.

Documentation saves time: Good documentation helps future developers (including future me) understand the code. I leverage AI assistants to spot unclear sections and suggest refactors, then I validate proposals with tests and reviews.

Improving My Skills

I’m focusing on:

• Reading clean code principles
• Studying well-written open source projects
• Refactoring my old code to be more maintainable
• Learning about design patterns
• Understanding when to apply different approaches

Growth Focus

During this period, I’m concentrating on:

• Writing cleaner, more maintainable code
• Understanding software design principles
• Learning industry best practices
• Improving my debugging skills
• Thinking about long-term maintainability

Working on Real Problems

Around this time, I’m starting to take on small independent projects mostly through referrals from friends and family.

These aren’t large commercial projects, but they’re real:

• Small business websites
• Simple management systems
• Tools to automate specific tasks

The key difference from practice projects: real users with real needs.

What This Is Teaching Me

Communication is crucial: Understanding what clients actually need (vs. what they say they want) is a skill.

Requirements change: What seems clear at the start often evolves as we work together.

Delivery matters: It’s not done until it’s deployed and the client can use it. AI helps me summarize requirements and prepare simple agreements so expectations stay aligned.

Support is part of the job: After delivery, there are questions, small fixes, and adjustments.

Balancing Learning and Work

I’m still a full-time student, so I have to balance:

• University coursework
• Intensive self-study
• These small projects
• Personal time (though I’m sacrificing a lot of this)

Time management is becoming essential.

Growth Focus

This experience is helping me develop:

• Professional communication skills
• Understanding business requirements
• Delivering complete, working solutions
• Managing expectations and timelines

Moving Beyond Simple Projects

After about a year of learning, I’m starting to build more complex applications that require:

• Persistent data storage with databases
• User authentication and authorization
• More sophisticated business logic
• Better error handling

These aren’t just practice projects they’re systems that can actually be used.

What I’m Learning

Database design matters: How you structure your data affects everything else. I’m learning about relationships, normalization, and indexing.

Authentication is complex: Implementing secure login systems is teaching me about hashing, sessions, tokens, and security best practices.

Error handling is crucial: Real applications need to handle errors gracefully, not just crash. AI assistants help me map failure modes and outline error‑handling paths before I implement them.

Code organization matters: As projects grow, I’m learning to organize code into modules and separate concerns.

Projects I’m Building

• A task management system with user accounts
• An inventory tracking application
• A booking system with calendar integration
• Various APIs for different use cases

Most of these are learning projects or small independent work, but they’re teaching me how real systems are structured.

Growth Focus

During this period, I’m concentrating on:

• Understanding backend architecture patterns
• Learning database modeling and optimization
• Implementing secure authentication
• Building RESTful APIs
• Writing maintainable, organized code

First Real Projects

After about a year of intensive learning, I’m feeling ready to build something for real users. I’m starting to take on small independent projects mostly through referrals from friends and family.

These aren’t large commercial projects, but they’re real:

• A small business website with a contact form
• An inventory management system for a local shop
• A simple booking system for a service provider

New Challenges

Working on real projects is different from practice projects:

Understanding requirements: Clients often don’t know exactly what they want. I have to ask the right questions.

Managing expectations: I’m learning to be clear about timelines and what’s feasible.

Handling feedback: Real users have opinions and requests that I haven’t anticipated.

Responsibility: If something doesn’t work, someone’s business is affected.

What I’m Learning

Communication matters: Writing good code isn’t enough. I need to explain technical decisions in simple terms.

Simple solutions are often better: I’m learning not to over-engineer. The goal is to solve the problem, not to use every technology I know. I use AI assistants to draft clearer proposals and structure requirement lists so conversations with clients stay focused.

Testing is crucial: Bugs in production are much more stressful than bugs in practice projects.

Balancing Studies and Projects

During this time, I’m still a full-time student. I have to balance:

• University coursework and exams
• Self-directed learning
• Independent projects
• Personal time (though I’m sacrificing a lot of social activities)

It’s challenging, but it’s teaching me time management and prioritization.

Growth Focus

This period is helping me develop:

• Professional communication skills
• Project planning and estimation
• Writing maintainable, production-ready code
• Debugging and troubleshooting under pressure

Understanding the Full Picture

After a few months of learning, I’m realizing that building real applications requires knowledge of multiple layers:

• Frontend (what users see and interact with)
• Backend (business logic and data processing)
• Databases (data storage and retrieval)
• APIs (communication between frontend and backend)

I’m deciding to focus on becoming a full-stack developer so I can build complete applications independently.

Learning the Stack

I’m starting to learn systematically:

Frontend: HTML, CSS, JavaScript, and later React Backend: Node.js and Express Databases: PostgreSQL and MongoDB Tools: Git, npm, and basic deployment concepts

Each project I build is helping me understand how these pieces fit together.

Building Practice Projects

I’m creating several projects to practice full-stack development:

• Todo applications with authentication
• Blog systems with CRUD operations
• Simple e-commerce prototypes
• API integrations with third-party services

Most of these projects are for learning purposes. Once I understand the concepts, I delete them and move on to more challenging problems.

Key Learnings

Everything is connected: Understanding how frontend, backend, and database work together is crucial.

Start simple, then add complexity: I’m learning to build the simplest version first, then add features incrementally.

Reading documentation is a skill: Official docs are becoming my primary learning resource. I also start experimenting with AI assistants to sketch endpoint examples and checklist test scenarios while I focus on learning the fundamentals.

Growth Focus

During this period, I’m concentrating on:

• Understanding RESTful API design
• Learning database modeling and relationships
• Building responsive user interfaces
• Connecting all the pieces into working applications

Starting University

In March 2021, I’m beginning my Computer Engineering degree at Universidad Autónoma Gabriel René Moreno (UAGRM). I’m excited to learn programming and build software systems.

During the first weeks, I’m realizing that while university provides a solid foundation, the pace is slower than I expected. I want to learn faster and build real projects.

Discovering Self-Directed Learning

I’m starting to explore resources beyond the classroom:

• MDN Web Docs (which is also motivating me to improve my English)
• YouTube tutorials from creators like MoureDev, Midudev, and Fazt
• Official documentation
• Google searches for specific problems

This is opening my eyes to how much knowledge is available online. I don’t have to wait for classes to learn something new.

Building My First Projects

I’m starting to build small projects to practice what I’m learning:

• Simple web pages with HTML, CSS, and JavaScript
• Basic CRUD applications
• Small APIs to understand backend concepts

Most of these early projects are learning exercises. I build something, learn from it, and then move on to the next challenge. I’m not keeping many of them because they’re stepping stones, not portfolio pieces.

Key Realizations

Learning is a skill: The most important thing I’m learning isn’t a specific technology, but how to learn effectively on my own.

Practice matters more than theory: Reading about programming isn’t enough. I need to write code every day.

English is essential: Most of the best resources are in English, which is pushing me to improve my language skills.

Growth Focus

At this stage, I’m focusing on:

• Building a strong foundation in programming fundamentals
• Developing consistent study habits
• Learning how to debug and solve problems independently
• Understanding how web applications work end-to-end