Technical training for teams

Tailored courses for teams already in production

Hands-on training to raise your team’s technical level without stopping the business: modern C++ and high performance, Go, Kubernetes, API architecture, web development with Ruby on Rails and Django, and statistical analysis with R. Taught by team members with university teaching experience; the profiles are on the Team page.

Tell us what your team wants to learn

Who it is for

  • Teams of 5 to 12 people already working in production who need to master a specific technology or technique.
  • Teams adopting modern C++, Go, or Kubernetes who want to avoid the mistakes that cost months.
  • One or two people who need focused training, in individual sessions.

It is not for you if…

  • you are looking for an introductory course for someone who has never programmed;
  • you need an official vendor certification;
  • you want a closed catalog: every course adapts to your team and your systems.

Our approach

  • Fundamentals that get applied. We work with real problems and discuss when a technique fits, when it fails, and how to check it, with the code and tools you’ll use in production.
  • Tailored. We adapt the content to your team and your systems; before the course we review a fragment of your code or your architecture if you authorize it.
  • Hands-on. Most of the time is spent on real code; theory comes in when it explains why a solution works.
  • Follow-up. Two question-and-answer sessions after the course and questions by email for 30 days.

Learning without thought is labor lost; thought without learning is perilous.

Confucius, Analects, 2.15. Source. Translation by James Legge (1893).
We teach fundamentals, put them to the test, and discuss their limits. The goal is for your team to decide on its own when the problem changes.

Courses

Modern C++ (C++17/20/23)

Who it is for: teams that already program in C++ and want to write safe, fast code with the modern standard. By the end you will be able to: manage resources without leaks with RAII and smart pointers, write generic code with templates, use the standard library and concurrency with judgment, and measure performance before optimizing.

  • Smart pointers and RAII
  • Move semantics and perfect forwarding
  • Practical templates and metaprogramming
  • Standard library and modern algorithms
  • Concurrency with std::thread and std::async
  • Performance optimization and profiling
  • Duration: 4 or 5 days · Level: intermediate and advanced

High-performance computing

Who it is for: teams that need to squeeze the CPU and the memory in systems where milliseconds matter. By the end you will be able to: reason about cache and memory, measure with a profiler and a benchmark, choose between concurrency and parallelism, and apply lock-free structures and vectorization where they pay off.

  • CPU architecture and cache behavior
  • Profiling and benchmarks
  • Concurrency versus parallelism
  • Lock-free data structures
  • SIMD and vectorization
  • Memory optimization
  • Duration: 3 days · Level: advanced

Go for backend

Who it is for: teams adopting Go for web services and APIs. By the end you will be able to: write idiomatic services, use goroutines and channels without race conditions, access databases with proven patterns, and profile a service in production.

  • Go fundamentals and idioms
  • Concurrency patterns with goroutines and channels
  • HTTP servers and middleware
  • Database access patterns
  • Unit, integration, and end-to-end tests
  • Profiling and optimization
  • Duration: 3 days · Level: beginner and intermediate

Kubernetes for developers

Who it is for: teams that deploy their services on Kubernetes and want to operate them with judgment. By the end you will be able to: describe a complete deployment, manage configuration and secrets, size resources and autoscaling, and diagnose a service in production.

  • Core concepts: pods, services, and deployments
  • ConfigMaps, secrets, and configuration management
  • Resource management and autoscaling
  • Health checks and self-healing
  • Helm and GitOps
  • Production diagnosis
  • Duration: 3 days · Level: intermediate

API architecture

Who it is for: teams that design or maintain APIs consumed by other teams or by customers. By the end you will be able to: choose between REST and gRPC, version without breaking clients, limit traffic and authenticate, and document with OpenAPI.

  • REST versus gRPC: when to use each
  • API design best practices
  • Versioning and backward compatibility
  • Traffic limiting, authentication, and authorization
  • Testing and documentation with OpenAPI
  • Duration: 2 or 3 days · Level: intermediate

Ruby on Rails: from idea to production

Who it is for: teams building complete web applications with Rails. By the end you will be able to: structure a scalable and secure application, test it with RSpec and Capybara, optimize queries with Active Record, and deploy it continuously.

  • Scalable and secure application architecture
  • Testing with RSpec and Capybara
  • Query optimization and Active Record
  • Continuous deployment and maintenance
  • Duration: 3 or 4 days · Level: intermediate and advanced

Django: web applications with Python

Who it is for: teams building applications and APIs with Django. By the end you will be able to: organize a large project, expose APIs with Django REST Framework, secure authentication, and run asynchronous tasks with Celery and Redis.

  • Large-scale project structure
  • Django REST Framework for APIs
  • Security, authentication, and middleware
  • Asynchronous tasks with Celery and Redis
  • Duration: 3 or 4 days · Level: intermediate and advanced

Statistical analysis with R

Who it is for: data teams that analyze and present results with R. By the end you will be able to: transform data with dplyr, visualize with ggplot2, build reproducible loading processes, and validate results with tests.

  • Data manipulation with dplyr
  • Visualization with ggplot2
  • Reproducible loading and transformation processes
  • Result validation and unit tests in R
  • Duration: 3 or 4 days · Level: intermediate and advanced

Custom courses

Don’t see what you need? We design a course for your team on topics such as domain-driven design, event-driven architectures, database design and optimization, security, continuous integration and deployment, or microservices.

Formats

  • At your company, on site: for teams of 5 to 12 people, in your offices; travel is quoted separately.
  • At your company, remote: live sessions by video call, with the same dynamic and no travel costs.
  • Individual or in small groups: sessions for one person or for groups of two or three.

Included in every course

  • Course material: slides, code, and exercises.
  • Access to a private repository with the examples.
  • Certificate of participation.
  • Two question-and-answer sessions after the course, one to two hours each.
  • Questions by email during the following 30 days.

Pricing

The amounts are references; the exact price is set in the proposal, per cohort, by level, duration, format and group size.

  • 2-day course at your company, up to 12 people: USD 3,500.
  • 3-day course at your company, up to 12 people: USD 5,000.
  • Individual sessions: USD 200 per hour.

Electronic invoice: in Colombian pesos for clients in Colombia, with the amount fixed in the proposal; in US dollars or euros for clients in other countries, paid by international bank transfer.

How we start

  1. Free 30-minute discovery call: what your team needs to learn, its level, and its systems.
  2. Proposal: a tailored program, dates, format, and a fixed price.
  3. Preparation: pre-course material if needed and, if you authorize it, a review of your code or your architecture to use your own examples.
  4. Course and follow-up: intensive, hands-on sessions, with the follow-up included in every course.

Tell us what your team wants to learn or write to us at contact@simylresearch.com.