“Just in time knowledge” and the value of knowing a little

To be a good software developer you need to know some things very well. You can’t get away without actually knowing your programming language of choice, or learning good software development practices. Beside mastering some skills, you should also have a large amount of general, high-level knowledge. This blog post is about this knowledge.

The concept of “Just in time knowledge”

The idea behind “Just in time knowledge” (from this point JITK) is to be able to get the knowledge that you need, only when you need it. For example, actually learning how to use Kafka, only when you need to work with Kafka.

The concept of JITK is strongly related to “Just in time learning”, but I see it as more basic. Sometimes you need only just enough knowledge about a technology, rather than actually learning how to use it.

Before you decide that this sounds awful, let’s consider cases where such knowledge may be useful.

Applications of “Just in time knowledge”

  • When choosing the right technology – often you need to consider multiple technologies that could fulfil your needs. Google can help here, but that selection process will be easier and more informed when you know where to start. At least knowing what is out there can be very helpful and will speed up the process.
  • When designing software solutions – software design in practice is influenced by the availability of different tools and technologies. For example, when designing a microservices system, you may not consider service mesh approach if you don’t know that it is something worth considering.
  • When solving bugs/issues – people working with software spend a lot of their time tracking down bugs and troubleshooting issues. Knowing what can possibly go wrong will make this process much easier, even if you don’t already know all the details.
  • When learning new technology – a particularly useful case of JITK is learning new technologies. You don’t need to know everything about programming language to start using it. It is often easier to get started and fill in the blanks as you go (I suggest doing that in the context of personal learning, not necessarily professional development).

I am sure that there are many more applications for “Just in time knowledge”. The message here is- this is a useful technique that should be used alongside mastery in some core technical skills.

Going broad rather than going deep

To start applying the JITK approach, you should cultivate a broad high-level knowledge of multiple topics. An example list of things worth knowing about for a software developer focused on JVM microservices would be:

  • Programming languages
  • Microservices patterns
  • SOA
  • Enterprise Java
  • Spring
  • Microframeworks
  • Kubernetes
  • AWS / Azure cloud
  • Choreography/Orchestration
  • Security
  • Testing
  • DevOps
  • Continuous Integration / Continous Delivery
  • Service Mesh
  • API Gateway
  • Agile Development practices
  • Monitoring
  • Debugging
  • API Design
  • and many more…

I do not suggest becoming an expert in every single topic listed here, but it is helpful to have some ideas what each of these fields/topics contain.

With the high-level knowledge of multiple topics, you will be less likely to make major mistakes, as you will “know what you don’t know”.

How to stay informed with all the technology and processes?

I have explained what you should know, so it is only fair to provide some ideas on how to foster this knowledge:


I hope this blog post will give you some extra motivation for learning about things that are outside of your comfort zone. Mastery is important, but to become a great software developer, you need to know at least a little bit about a lot of things! Good luck!